2 Unix SMB/CIFS implementation.
3 RAW_OPEN_* individual test suite
4 Copyright (C) Andrew Tridgell 2003
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
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.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include "libcli/raw/libcliraw.h"
22 #include "system/time.h"
23 #include "system/filesys.h"
24 #include "lib/events/events.h"
25 #include "libcli/libcli.h"
26 #include "torture/util.h"
27 #include "torture/raw/proto.h"
29 /* enum for whether reads/writes are possible on a file */
30 enum rdwr_mode
{RDWR_NONE
, RDWR_RDONLY
, RDWR_WRONLY
, RDWR_RDWR
};
32 #define BASEDIR "\\rawopen"
35 check if a open file can be read/written
37 static enum rdwr_mode
check_rdwr(struct smbcli_tree
*tree
, int fnum
)
40 bool can_read
= (smbcli_read(tree
, fnum
, &c
, 0, 1) == 1);
41 bool can_write
= (smbcli_write(tree
, fnum
, 0, &c
, 0, 1) == 1);
42 if ( can_read
&& can_write
) return RDWR_RDWR
;
43 if ( can_read
&& !can_write
) return RDWR_RDONLY
;
44 if (!can_read
&& can_write
) return RDWR_WRONLY
;
49 describe a RDWR mode as a string
51 static const char *rdwr_string(enum rdwr_mode m
)
54 case RDWR_NONE
: return "NONE";
55 case RDWR_RDONLY
: return "RDONLY";
56 case RDWR_WRONLY
: return "WRONLY";
57 case RDWR_RDWR
: return "RDWR";
62 #define CHECK_STATUS(status, correct) do { \
63 if (!NT_STATUS_EQUAL(status, correct)) { \
64 torture_result(tctx, TORTURE_FAIL, \
65 "(%s) Incorrect status %s - should be %s\n", \
66 __location__, nt_errstr(status), nt_errstr(correct)); \
71 #define CREATE_FILE do { \
72 fnum = create_complex_file(cli, tctx, fname); \
74 torture_result(tctx, TORTURE_FAIL, \
75 "(%s) Failed to create %s - %s\n", \
76 __location__, fname, smbcli_errstr(cli->tree)); \
81 #define CHECK_RDWR(fnum, correct) do { \
82 enum rdwr_mode m = check_rdwr(cli->tree, fnum); \
84 torture_result(tctx, TORTURE_FAIL, \
85 "(%s) Incorrect readwrite mode %s - expected %s\n", \
86 __location__, rdwr_string(m), rdwr_string(correct)); \
90 #define CHECK_TIME(t, field) do { \
92 finfo.all_info.level = RAW_FILEINFO_ALL_INFO; \
93 finfo.all_info.in.file.path = fname; \
94 status = smb_raw_pathinfo(cli->tree, tctx, &finfo); \
95 CHECK_STATUS(status, NT_STATUS_OK); \
97 t2 = nt_time_to_unix(finfo.all_info.out.field) & ~1; \
98 if (abs(t1-t2) > 2) { \
99 torture_result(tctx, TORTURE_FAIL, \
100 "(%s) wrong time for field %s %s - %s\n", \
101 __location__, #field, \
102 timestring(tctx, t1), \
103 timestring(tctx, t2)); \
104 dump_all_info(tctx, &finfo); \
108 #define CHECK_NTTIME(t, field) do { \
110 finfo.all_info.level = RAW_FILEINFO_ALL_INFO; \
111 finfo.all_info.in.file.path = fname; \
112 status = smb_raw_pathinfo(cli->tree, tctx, &finfo); \
113 CHECK_STATUS(status, NT_STATUS_OK); \
114 t2 = finfo.all_info.out.field; \
116 torture_result(tctx, TORTURE_FAIL, \
117 "(%s) wrong time for field %s %s - %s\n", \
118 __location__, #field, \
119 nt_time_string(tctx, t), \
120 nt_time_string(tctx, t2)); \
121 dump_all_info(tctx, &finfo); \
125 #define CHECK_ALL_INFO(v, field) do { \
126 finfo.all_info.level = RAW_FILEINFO_ALL_INFO; \
127 finfo.all_info.in.file.path = fname; \
128 status = smb_raw_pathinfo(cli->tree, tctx, &finfo); \
129 CHECK_STATUS(status, NT_STATUS_OK); \
130 if ((v) != (finfo.all_info.out.field)) { \
131 torture_result(tctx, TORTURE_FAIL, \
132 "(%s) wrong value for field %s 0x%x - 0x%x\n", \
133 __location__, #field, (unsigned int)(v), (unsigned int)(finfo.all_info.out.field)); \
134 dump_all_info(tctx, &finfo); \
138 #define CHECK_VAL(v, correct) do { \
139 if ((v) != (correct)) { \
140 torture_result(tctx, TORTURE_FAIL, \
141 "(%s) wrong value for %s 0x%x - should be 0x%x\n", \
142 __location__, #v, (unsigned int)(v), (unsigned int)(correct)); \
146 #define SET_ATTRIB(sattrib) do { \
147 union smb_setfileinfo sfinfo; \
148 ZERO_STRUCT(sfinfo.basic_info.in); \
149 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFORMATION; \
150 sfinfo.basic_info.in.file.path = fname; \
151 sfinfo.basic_info.in.attrib = sattrib; \
152 status = smb_raw_setpathinfo(cli->tree, &sfinfo); \
153 if (!NT_STATUS_IS_OK(status)) { \
154 torture_warning(tctx, "(%s) Failed to set attrib 0x%x on %s\n", \
155 __location__, (unsigned int)(sattrib), fname); \
161 static bool test_open(struct torture_context
*tctx
, struct smbcli_state
*cli
)
164 union smb_fileinfo finfo
;
165 const char *fname
= BASEDIR
"\\torture_open.txt";
167 int fnum
= -1, fnum2
;
170 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
172 io
.openold
.level
= RAW_OPEN_OPEN
;
173 io
.openold
.in
.fname
= fname
;
174 io
.openold
.in
.open_mode
= OPEN_FLAGS_FCB
;
175 io
.openold
.in
.search_attrs
= 0;
176 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
177 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
178 fnum
= io
.openold
.out
.file
.fnum
;
180 smbcli_unlink(cli
->tree
, fname
);
182 smbcli_close(cli
->tree
, fnum
);
184 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
185 CHECK_STATUS(status
, NT_STATUS_OK
);
186 fnum
= io
.openold
.out
.file
.fnum
;
187 CHECK_RDWR(fnum
, RDWR_RDWR
);
189 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
190 CHECK_STATUS(status
, NT_STATUS_OK
);
191 fnum2
= io
.openold
.out
.file
.fnum
;
192 CHECK_RDWR(fnum2
, RDWR_RDWR
);
193 smbcli_close(cli
->tree
, fnum2
);
194 smbcli_close(cli
->tree
, fnum
);
196 /* check the read/write modes */
197 io
.openold
.level
= RAW_OPEN_OPEN
;
198 io
.openold
.in
.fname
= fname
;
199 io
.openold
.in
.search_attrs
= 0;
201 io
.openold
.in
.open_mode
= OPEN_FLAGS_OPEN_READ
;
202 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
203 CHECK_STATUS(status
, NT_STATUS_OK
);
204 fnum
= io
.openold
.out
.file
.fnum
;
205 CHECK_RDWR(fnum
, RDWR_RDONLY
);
206 smbcli_close(cli
->tree
, fnum
);
208 io
.openold
.in
.open_mode
= OPEN_FLAGS_OPEN_WRITE
;
209 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
210 CHECK_STATUS(status
, NT_STATUS_OK
);
211 fnum
= io
.openold
.out
.file
.fnum
;
212 CHECK_RDWR(fnum
, RDWR_WRONLY
);
213 smbcli_close(cli
->tree
, fnum
);
215 io
.openold
.in
.open_mode
= OPEN_FLAGS_OPEN_RDWR
;
216 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
217 CHECK_STATUS(status
, NT_STATUS_OK
);
218 fnum
= io
.openold
.out
.file
.fnum
;
219 CHECK_RDWR(fnum
, RDWR_RDWR
);
220 smbcli_close(cli
->tree
, fnum
);
222 /* check the share modes roughly - not a complete matrix */
223 io
.openold
.in
.open_mode
= OPEN_FLAGS_OPEN_RDWR
| OPEN_FLAGS_DENY_WRITE
;
224 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
225 CHECK_STATUS(status
, NT_STATUS_OK
);
226 fnum
= io
.openold
.out
.file
.fnum
;
227 CHECK_RDWR(fnum
, RDWR_RDWR
);
229 if (io
.openold
.in
.open_mode
!= io
.openold
.out
.rmode
) {
230 torture_warning(tctx
, "(%s) rmode should equal open_mode - 0x%x 0x%x\n",
231 __location__
, io
.openold
.out
.rmode
, io
.openold
.in
.open_mode
);
234 io
.openold
.in
.open_mode
= OPEN_FLAGS_OPEN_RDWR
| OPEN_FLAGS_DENY_NONE
;
235 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
236 CHECK_STATUS(status
, NT_STATUS_SHARING_VIOLATION
);
238 io
.openold
.in
.open_mode
= OPEN_FLAGS_OPEN_READ
| OPEN_FLAGS_DENY_NONE
;
239 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
240 CHECK_STATUS(status
, NT_STATUS_OK
);
241 fnum2
= io
.openold
.out
.file
.fnum
;
242 CHECK_RDWR(fnum2
, RDWR_RDONLY
);
243 smbcli_close(cli
->tree
, fnum
);
244 smbcli_close(cli
->tree
, fnum2
);
247 /* check the returned write time */
248 io
.openold
.level
= RAW_OPEN_OPEN
;
249 io
.openold
.in
.fname
= fname
;
250 io
.openold
.in
.search_attrs
= 0;
251 io
.openold
.in
.open_mode
= OPEN_FLAGS_OPEN_READ
;
252 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
253 CHECK_STATUS(status
, NT_STATUS_OK
);
254 fnum
= io
.openold
.out
.file
.fnum
;
256 /* check other reply fields */
257 CHECK_TIME(io
.openold
.out
.write_time
, write_time
);
258 CHECK_ALL_INFO(io
.openold
.out
.size
, size
);
259 CHECK_ALL_INFO(io
.openold
.out
.attrib
, attrib
& ~FILE_ATTRIBUTE_NONINDEXED
);
262 smbcli_close(cli
->tree
, fnum
);
263 smbcli_deltree(cli
->tree
, BASEDIR
);
272 static bool test_openx(struct torture_context
*tctx
, struct smbcli_state
*cli
)
275 union smb_fileinfo finfo
;
276 const char *fname
= BASEDIR
"\\torture_openx.txt";
277 const char *fname_exe
= BASEDIR
"\\torture_openx.exe";
279 int fnum
= -1, fnum2
;
286 NTSTATUS correct_status
;
288 { OPENX_OPEN_FUNC_OPEN
, true, NT_STATUS_OK
},
289 { OPENX_OPEN_FUNC_OPEN
, false, NT_STATUS_OBJECT_NAME_NOT_FOUND
},
290 { OPENX_OPEN_FUNC_OPEN
| OPENX_OPEN_FUNC_CREATE
, true, NT_STATUS_OK
},
291 { OPENX_OPEN_FUNC_OPEN
| OPENX_OPEN_FUNC_CREATE
, false, NT_STATUS_OK
},
292 { OPENX_OPEN_FUNC_FAIL
, true, NT_STATUS_DOS(ERRDOS
, ERRbadaccess
) },
293 { OPENX_OPEN_FUNC_FAIL
, false, NT_STATUS_DOS(ERRDOS
, ERRbadaccess
) },
294 { OPENX_OPEN_FUNC_FAIL
| OPENX_OPEN_FUNC_CREATE
, true, NT_STATUS_OBJECT_NAME_COLLISION
},
295 { OPENX_OPEN_FUNC_FAIL
| OPENX_OPEN_FUNC_CREATE
, false, NT_STATUS_OK
},
296 { OPENX_OPEN_FUNC_TRUNC
, true, NT_STATUS_OK
},
297 { OPENX_OPEN_FUNC_TRUNC
, false, NT_STATUS_OBJECT_NAME_NOT_FOUND
},
298 { OPENX_OPEN_FUNC_TRUNC
| OPENX_OPEN_FUNC_CREATE
, true, NT_STATUS_OK
},
299 { OPENX_OPEN_FUNC_TRUNC
| OPENX_OPEN_FUNC_CREATE
, false, NT_STATUS_OK
},
302 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
304 io
.openx
.level
= RAW_OPEN_OPENX
;
305 io
.openx
.in
.fname
= fname
;
306 io
.openx
.in
.flags
= OPENX_FLAGS_ADDITIONAL_INFO
;
307 io
.openx
.in
.open_mode
= OPENX_MODE_ACCESS_RDWR
;
308 io
.openx
.in
.search_attrs
= 0;
309 io
.openx
.in
.file_attrs
= 0;
310 io
.openx
.in
.write_time
= 0;
311 io
.openx
.in
.size
= 1024*1024;
312 io
.openx
.in
.timeout
= 0;
314 /* check all combinations of open_func */
315 for (i
=0; i
<ARRAY_SIZE(open_funcs
); i
++) {
316 if (open_funcs
[i
].with_file
) {
317 fnum
= create_complex_file(cli
, tctx
, fname
);
319 torture_result(tctx
, TORTURE_FAIL
,
320 "Failed to create file %s - %s\n",
321 fname
, smbcli_errstr(cli
->tree
));
325 smbcli_close(cli
->tree
, fnum
);
327 io
.openx
.in
.open_func
= open_funcs
[i
].open_func
;
328 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
329 if (!NT_STATUS_EQUAL(status
, open_funcs
[i
].correct_status
)) {
330 torture_result(tctx
, TORTURE_FAIL
,
331 "(%s) incorrect status %s should be %s "
332 "(i=%d with_file=%d open_func=0x%x)\n",
333 __location__
, nt_errstr(status
),
334 nt_errstr(open_funcs
[i
].correct_status
),
335 i
, (int)open_funcs
[i
].with_file
,
336 open_funcs
[i
].open_func
);
339 if (NT_STATUS_IS_OK(status
)) {
340 smbcli_close(cli
->tree
, io
.openx
.out
.file
.fnum
);
342 if (open_funcs
[i
].with_file
) {
343 smbcli_unlink(cli
->tree
, fname
);
347 smbcli_unlink(cli
->tree
, fname
);
349 /* check the basic return fields */
350 io
.openx
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
| OPENX_OPEN_FUNC_CREATE
;
351 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
352 CHECK_STATUS(status
, NT_STATUS_OK
);
353 fnum
= io
.openx
.out
.file
.fnum
;
355 CHECK_ALL_INFO(io
.openx
.out
.size
, size
);
356 CHECK_TIME(io
.openx
.out
.write_time
, write_time
);
357 CHECK_ALL_INFO(io
.openx
.out
.attrib
, attrib
& ~FILE_ATTRIBUTE_NONINDEXED
);
358 CHECK_VAL(io
.openx
.out
.access
, OPENX_MODE_ACCESS_RDWR
);
359 CHECK_VAL(io
.openx
.out
.ftype
, 0);
360 CHECK_VAL(io
.openx
.out
.devstate
, 0);
361 CHECK_VAL(io
.openx
.out
.action
, OPENX_ACTION_CREATED
);
362 CHECK_VAL(io
.openx
.out
.size
, 1024*1024);
363 CHECK_ALL_INFO(io
.openx
.in
.size
, size
);
364 smbcli_close(cli
->tree
, fnum
);
365 smbcli_unlink(cli
->tree
, fname
);
367 /* check the fields when the file already existed */
368 fnum2
= create_complex_file(cli
, tctx
, fname
);
373 smbcli_close(cli
->tree
, fnum2
);
375 io
.openx
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
;
376 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
377 CHECK_STATUS(status
, NT_STATUS_OK
);
378 fnum
= io
.openx
.out
.file
.fnum
;
380 CHECK_ALL_INFO(io
.openx
.out
.size
, size
);
381 CHECK_TIME(io
.openx
.out
.write_time
, write_time
);
382 CHECK_VAL(io
.openx
.out
.action
, OPENX_ACTION_EXISTED
);
383 CHECK_VAL(io
.openx
.out
.unknown
, 0);
384 CHECK_ALL_INFO(io
.openx
.out
.attrib
, attrib
& ~FILE_ATTRIBUTE_NONINDEXED
);
385 smbcli_close(cli
->tree
, fnum
);
387 /* now check the search attrib for hidden files - win2003 ignores this? */
388 SET_ATTRIB(FILE_ATTRIBUTE_HIDDEN
);
389 CHECK_ALL_INFO(FILE_ATTRIBUTE_HIDDEN
, attrib
);
391 io
.openx
.in
.search_attrs
= FILE_ATTRIBUTE_HIDDEN
;
392 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
393 CHECK_STATUS(status
, NT_STATUS_OK
);
394 smbcli_close(cli
->tree
, io
.openx
.out
.file
.fnum
);
396 io
.openx
.in
.search_attrs
= 0;
397 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
398 CHECK_STATUS(status
, NT_STATUS_OK
);
399 smbcli_close(cli
->tree
, io
.openx
.out
.file
.fnum
);
401 SET_ATTRIB(FILE_ATTRIBUTE_NORMAL
);
402 smbcli_unlink(cli
->tree
, fname
);
404 /* and check attrib on create */
405 io
.openx
.in
.open_func
= OPENX_OPEN_FUNC_FAIL
| OPENX_OPEN_FUNC_CREATE
;
406 io
.openx
.in
.search_attrs
= 0;
407 io
.openx
.in
.file_attrs
= FILE_ATTRIBUTE_SYSTEM
;
408 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
409 CHECK_STATUS(status
, NT_STATUS_OK
);
410 if (torture_setting_bool(tctx
, "samba3", false)) {
411 CHECK_ALL_INFO(FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_ARCHIVE
,
412 attrib
& ~(FILE_ATTRIBUTE_NONINDEXED
|
413 FILE_ATTRIBUTE_SPARSE
));
416 CHECK_ALL_INFO(FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_ARCHIVE
,
417 attrib
& ~(FILE_ATTRIBUTE_NONINDEXED
));
419 smbcli_close(cli
->tree
, io
.openx
.out
.file
.fnum
);
420 smbcli_unlink(cli
->tree
, fname
);
422 /* check timeout on create - win2003 ignores the timeout! */
423 io
.openx
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
| OPENX_OPEN_FUNC_CREATE
;
424 io
.openx
.in
.file_attrs
= 0;
425 io
.openx
.in
.open_mode
= OPENX_MODE_ACCESS_RDWR
| OPENX_MODE_DENY_ALL
;
426 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
427 CHECK_STATUS(status
, NT_STATUS_OK
);
428 fnum
= io
.openx
.out
.file
.fnum
;
430 io
.openx
.in
.timeout
= 20000;
431 tv
= timeval_current();
432 io
.openx
.in
.open_mode
= OPENX_MODE_ACCESS_RDWR
| OPENX_MODE_DENY_NONE
;
433 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
434 CHECK_STATUS(status
, NT_STATUS_SHARING_VIOLATION
);
435 if (timeval_elapsed(&tv
) > 3.0) {
436 torture_result(tctx
, TORTURE_FAIL
,
437 "(%s) Incorrect timing in openx with timeout "
438 "- waited %.2f seconds\n",
439 __location__
, timeval_elapsed(&tv
));
442 smbcli_close(cli
->tree
, fnum
);
443 smbcli_unlink(cli
->tree
, fname
);
445 /* now this is a really weird one - open for execute implies create?! */
446 io
.openx
.in
.fname
= fname
;
447 io
.openx
.in
.flags
= OPENX_FLAGS_ADDITIONAL_INFO
;
448 io
.openx
.in
.open_mode
= OPENX_MODE_ACCESS_EXEC
| OPENX_MODE_DENY_NONE
;
449 io
.openx
.in
.search_attrs
= 0;
450 io
.openx
.in
.open_func
= OPENX_OPEN_FUNC_FAIL
;
451 io
.openx
.in
.file_attrs
= 0;
452 io
.openx
.in
.write_time
= 0;
453 io
.openx
.in
.size
= 0;
454 io
.openx
.in
.timeout
= 0;
455 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
456 CHECK_STATUS(status
, NT_STATUS_OK
);
457 smbcli_close(cli
->tree
, io
.openx
.out
.file
.fnum
);
459 /* check the extended return flag */
460 io
.openx
.in
.flags
= OPENX_FLAGS_ADDITIONAL_INFO
| OPENX_FLAGS_EXTENDED_RETURN
;
461 io
.openx
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
;
462 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
463 CHECK_STATUS(status
, NT_STATUS_OK
);
464 CHECK_VAL(io
.openx
.out
.access_mask
, SEC_STD_ALL
);
465 smbcli_close(cli
->tree
, io
.openx
.out
.file
.fnum
);
467 io
.openx
.in
.fname
= "\\A.+,;=[].B";
468 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
469 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
471 /* Check the mapping for open exec. */
473 /* First create an .exe file. */
474 smbcli_unlink(cli
->tree
, fname_exe
);
475 fnum
= create_complex_file(cli
, tctx
, fname_exe
);
476 smbcli_close(cli
->tree
, fnum
);
478 io
.openx
.level
= RAW_OPEN_OPENX
;
479 io
.openx
.in
.fname
= fname_exe
;
480 io
.openx
.in
.flags
= OPENX_FLAGS_ADDITIONAL_INFO
;
481 io
.openx
.in
.open_mode
= OPENX_MODE_ACCESS_EXEC
| OPENX_MODE_DENY_NONE
;
482 io
.openx
.in
.search_attrs
= 0;
483 io
.openx
.in
.file_attrs
= 0;
484 io
.openx
.in
.write_time
= 0;
485 io
.openx
.in
.size
= 0;
486 io
.openx
.in
.timeout
= 0;
487 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
488 CHECK_STATUS(status
, NT_STATUS_OK
);
490 /* Can we read and write ? */
491 CHECK_RDWR(io
.openx
.out
.file
.fnum
, RDWR_RDONLY
);
492 smbcli_close(cli
->tree
, io
.openx
.out
.file
.fnum
);
493 smbcli_unlink(cli
->tree
, fname
);
496 smbcli_close(cli
->tree
, fnum
);
497 smbcli_deltree(cli
->tree
, BASEDIR
);
506 many thanks to kukks for a sniff showing how this works with os2->w2k
508 static bool test_t2open(struct torture_context
*tctx
, struct smbcli_state
*cli
)
511 union smb_fileinfo finfo
;
512 const char *fname1
= BASEDIR
"\\torture_t2open_yes.txt";
513 const char *fname2
= BASEDIR
"\\torture_t2open_no.txt";
514 const char *fname
= BASEDIR
"\\torture_t2open_3.txt";
522 NTSTATUS correct_status
;
524 { OPENX_OPEN_FUNC_OPEN
, true, NT_STATUS_OK
},
525 { OPENX_OPEN_FUNC_OPEN
, false, NT_STATUS_OBJECT_NAME_NOT_FOUND
},
526 { OPENX_OPEN_FUNC_OPEN
| OPENX_OPEN_FUNC_CREATE
, true, NT_STATUS_OK
},
527 { OPENX_OPEN_FUNC_OPEN
| OPENX_OPEN_FUNC_CREATE
, false, NT_STATUS_OK
},
528 { OPENX_OPEN_FUNC_FAIL
, true, NT_STATUS_OBJECT_NAME_COLLISION
},
529 { OPENX_OPEN_FUNC_FAIL
, false, NT_STATUS_OBJECT_NAME_COLLISION
},
530 { OPENX_OPEN_FUNC_FAIL
| OPENX_OPEN_FUNC_CREATE
, true, NT_STATUS_OBJECT_NAME_COLLISION
},
531 { OPENX_OPEN_FUNC_FAIL
| OPENX_OPEN_FUNC_CREATE
, false, NT_STATUS_OBJECT_NAME_COLLISION
},
532 { OPENX_OPEN_FUNC_TRUNC
, true, NT_STATUS_OK
},
533 { OPENX_OPEN_FUNC_TRUNC
, false, NT_STATUS_OK
},
534 { OPENX_OPEN_FUNC_TRUNC
| OPENX_OPEN_FUNC_CREATE
, true, NT_STATUS_OK
},
535 { OPENX_OPEN_FUNC_TRUNC
| OPENX_OPEN_FUNC_CREATE
, false, NT_STATUS_OK
},
538 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
540 fnum
= create_complex_file(cli
, tctx
, fname1
);
542 torture_result(tctx
, TORTURE_FAIL
,
543 "(%s): Failed to create file %s - %s\n",
544 __location__
, fname1
, smbcli_errstr(cli
->tree
));
548 smbcli_close(cli
->tree
, fnum
);
550 io
.t2open
.level
= RAW_OPEN_T2OPEN
;
551 io
.t2open
.in
.flags
= OPENX_FLAGS_ADDITIONAL_INFO
;
552 io
.t2open
.in
.open_mode
= OPENX_MODE_DENY_NONE
| OPENX_MODE_ACCESS_RDWR
;
553 io
.t2open
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
| OPENX_OPEN_FUNC_CREATE
;
554 io
.t2open
.in
.search_attrs
= 0;
555 io
.t2open
.in
.file_attrs
= 0;
556 io
.t2open
.in
.write_time
= 0;
557 io
.t2open
.in
.size
= 0;
558 io
.t2open
.in
.timeout
= 0;
560 io
.t2open
.in
.num_eas
= 3;
561 io
.t2open
.in
.eas
= talloc_array(tctx
, struct ea_struct
, io
.t2open
.in
.num_eas
);
562 io
.t2open
.in
.eas
[0].flags
= 0;
563 io
.t2open
.in
.eas
[0].name
.s
= ".CLASSINFO";
564 io
.t2open
.in
.eas
[0].value
= data_blob_talloc(tctx
, "first value", 11);
565 io
.t2open
.in
.eas
[1].flags
= 0;
566 io
.t2open
.in
.eas
[1].name
.s
= "EA TWO";
567 io
.t2open
.in
.eas
[1].value
= data_blob_talloc(tctx
, "foo", 3);
568 io
.t2open
.in
.eas
[2].flags
= 0;
569 io
.t2open
.in
.eas
[2].name
.s
= "X THIRD";
570 io
.t2open
.in
.eas
[2].value
= data_blob_talloc(tctx
, "xy", 2);
572 /* check all combinations of open_func */
573 for (i
=0; i
<ARRAY_SIZE(open_funcs
); i
++) {
575 if (open_funcs
[i
].with_file
) {
576 io
.t2open
.in
.fname
= fname1
;
578 io
.t2open
.in
.fname
= fname2
;
580 io
.t2open
.in
.open_func
= open_funcs
[i
].open_func
;
581 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
582 if ((io
.t2open
.in
.num_eas
!= 0)
583 && NT_STATUS_EQUAL(status
, NT_STATUS_EAS_NOT_SUPPORTED
)
584 && torture_setting_bool(tctx
, "samba3", false)) {
585 torture_warning(tctx
, "(%s) EAs not supported, not "
586 "treating as fatal in Samba3 test\n",
588 io
.t2open
.in
.num_eas
= 0;
592 if (!NT_STATUS_EQUAL(status
, open_funcs
[i
].correct_status
)) {
593 torture_result(tctx
, TORTURE_FAIL
,
594 "(%s) incorrect status %s should be %s "
595 "(i=%d with_file=%d open_func=0x%x)\n",
596 __location__
, nt_errstr(status
),
597 nt_errstr(open_funcs
[i
].correct_status
),
598 i
, (int)open_funcs
[i
].with_file
,
599 open_funcs
[i
].open_func
);
602 if (NT_STATUS_IS_OK(status
)) {
603 smbcli_close(cli
->tree
, io
.t2open
.out
.file
.fnum
);
607 smbcli_unlink(cli
->tree
, fname1
);
608 smbcli_unlink(cli
->tree
, fname2
);
610 /* check the basic return fields */
611 io
.t2open
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
| OPENX_OPEN_FUNC_CREATE
;
612 io
.t2open
.in
.write_time
= 0;
613 io
.t2open
.in
.fname
= fname
;
614 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
615 CHECK_STATUS(status
, NT_STATUS_OK
);
616 fnum
= io
.t2open
.out
.file
.fnum
;
618 CHECK_ALL_INFO(io
.t2open
.out
.size
, size
);
620 /* windows appears to leak uninitialised memory here */
621 CHECK_VAL(io
.t2open
.out
.write_time
, 0);
623 CHECK_ALL_INFO(io
.t2open
.out
.attrib
, attrib
& ~FILE_ATTRIBUTE_NONINDEXED
);
624 CHECK_VAL(io
.t2open
.out
.access
, OPENX_MODE_DENY_NONE
| OPENX_MODE_ACCESS_RDWR
);
625 CHECK_VAL(io
.t2open
.out
.ftype
, 0);
626 CHECK_VAL(io
.t2open
.out
.devstate
, 0);
627 CHECK_VAL(io
.t2open
.out
.action
, OPENX_ACTION_CREATED
);
628 smbcli_close(cli
->tree
, fnum
);
630 status
= torture_check_ea(cli
, fname
, ".CLASSINFO", "first value");
631 CHECK_STATUS(status
, io
.t2open
.in
.num_eas
632 ? NT_STATUS_OK
: NT_STATUS_EAS_NOT_SUPPORTED
);
633 status
= torture_check_ea(cli
, fname
, "EA TWO", "foo");
634 CHECK_STATUS(status
, io
.t2open
.in
.num_eas
635 ? NT_STATUS_OK
: NT_STATUS_EAS_NOT_SUPPORTED
);
636 status
= torture_check_ea(cli
, fname
, "X THIRD", "xy");
637 CHECK_STATUS(status
, io
.t2open
.in
.num_eas
638 ? NT_STATUS_OK
: NT_STATUS_EAS_NOT_SUPPORTED
);
640 /* now check the search attrib for hidden files - win2003 ignores this? */
641 SET_ATTRIB(FILE_ATTRIBUTE_HIDDEN
);
642 CHECK_ALL_INFO(FILE_ATTRIBUTE_HIDDEN
, attrib
);
644 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
645 CHECK_STATUS(status
, NT_STATUS_OK
);
646 smbcli_close(cli
->tree
, io
.t2open
.out
.file
.fnum
);
648 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
649 CHECK_STATUS(status
, NT_STATUS_OK
);
650 smbcli_close(cli
->tree
, io
.t2open
.out
.file
.fnum
);
652 SET_ATTRIB(FILE_ATTRIBUTE_NORMAL
);
653 smbcli_unlink(cli
->tree
, fname
);
655 /* and check attrib on create */
656 io
.t2open
.in
.open_func
= OPENX_OPEN_FUNC_FAIL
| OPENX_OPEN_FUNC_CREATE
;
657 io
.t2open
.in
.file_attrs
= FILE_ATTRIBUTE_SYSTEM
;
658 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
659 CHECK_STATUS(status
, NT_STATUS_OK
);
661 /* check timeout on create - win2003 ignores the timeout! */
662 io
.t2open
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
| OPENX_OPEN_FUNC_CREATE
;
663 io
.t2open
.in
.file_attrs
= 0;
664 io
.t2open
.in
.timeout
= 20000;
665 io
.t2open
.in
.open_mode
= OPENX_MODE_ACCESS_RDWR
| OPENX_MODE_DENY_ALL
;
666 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
667 CHECK_STATUS(status
, NT_STATUS_SHARING_VIOLATION
);
670 smbcli_close(cli
->tree
, fnum
);
671 smbcli_deltree(cli
->tree
, BASEDIR
);
678 test RAW_OPEN_NTCREATEX
680 static bool test_ntcreatex(struct torture_context
*tctx
, struct smbcli_state
*cli
)
683 union smb_fileinfo finfo
;
684 const char *fname
= BASEDIR
"\\torture_ntcreatex.txt";
685 const char *dname
= BASEDIR
"\\torture_ntcreatex.dir";
693 NTSTATUS correct_status
;
695 { NTCREATEX_DISP_SUPERSEDE
, true, NT_STATUS_OK
},
696 { NTCREATEX_DISP_SUPERSEDE
, false, NT_STATUS_OK
},
697 { NTCREATEX_DISP_OPEN
, true, NT_STATUS_OK
},
698 { NTCREATEX_DISP_OPEN
, false, NT_STATUS_OBJECT_NAME_NOT_FOUND
},
699 { NTCREATEX_DISP_CREATE
, true, NT_STATUS_OBJECT_NAME_COLLISION
},
700 { NTCREATEX_DISP_CREATE
, false, NT_STATUS_OK
},
701 { NTCREATEX_DISP_OPEN_IF
, true, NT_STATUS_OK
},
702 { NTCREATEX_DISP_OPEN_IF
, false, NT_STATUS_OK
},
703 { NTCREATEX_DISP_OVERWRITE
, true, NT_STATUS_OK
},
704 { NTCREATEX_DISP_OVERWRITE
, false, NT_STATUS_OBJECT_NAME_NOT_FOUND
},
705 { NTCREATEX_DISP_OVERWRITE_IF
, true, NT_STATUS_OK
},
706 { NTCREATEX_DISP_OVERWRITE_IF
, false, NT_STATUS_OK
},
707 { 6, true, NT_STATUS_INVALID_PARAMETER
},
708 { 6, false, NT_STATUS_INVALID_PARAMETER
},
711 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
713 /* reasonable default parameters */
714 io
.generic
.level
= RAW_OPEN_NTCREATEX
;
715 io
.ntcreatex
.in
.flags
= NTCREATEX_FLAGS_EXTENDED
;
716 io
.ntcreatex
.in
.root_fid
.fnum
= 0;
717 io
.ntcreatex
.in
.access_mask
= SEC_RIGHTS_FILE_ALL
;
718 io
.ntcreatex
.in
.alloc_size
= 1024*1024;
719 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
720 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_NONE
;
721 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
722 io
.ntcreatex
.in
.create_options
= 0;
723 io
.ntcreatex
.in
.impersonation
= NTCREATEX_IMPERSONATION_ANONYMOUS
;
724 io
.ntcreatex
.in
.security_flags
= 0;
725 io
.ntcreatex
.in
.fname
= fname
;
727 /* test the open disposition */
728 for (i
=0; i
<ARRAY_SIZE(open_funcs
); i
++) {
729 if (open_funcs
[i
].with_file
) {
730 fnum
= smbcli_open(cli
->tree
, fname
, O_CREAT
|O_RDWR
|O_TRUNC
, DENY_NONE
);
732 torture_result(tctx
, TORTURE_FAIL
,
733 "Failed to create file %s - %s\n",
734 fname
, smbcli_errstr(cli
->tree
));
738 smbcli_close(cli
->tree
, fnum
);
740 io
.ntcreatex
.in
.open_disposition
= open_funcs
[i
].open_disp
;
741 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
742 if (!NT_STATUS_EQUAL(status
, open_funcs
[i
].correct_status
)) {
743 torture_result(tctx
, TORTURE_FAIL
,
744 "(%s) incorrect status %s should be %s "
745 "(i=%d with_file=%d open_disp=%d)\n",
746 __location__
, nt_errstr(status
),
747 nt_errstr(open_funcs
[i
].correct_status
),
748 i
, (int)open_funcs
[i
].with_file
,
749 (int)open_funcs
[i
].open_disp
);
752 if (NT_STATUS_IS_OK(status
) || open_funcs
[i
].with_file
) {
753 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
754 smbcli_unlink(cli
->tree
, fname
);
758 /* basic field testing */
759 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
761 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
762 CHECK_STATUS(status
, NT_STATUS_OK
);
763 fnum
= io
.ntcreatex
.out
.file
.fnum
;
765 CHECK_VAL(io
.ntcreatex
.out
.oplock_level
, 0);
766 CHECK_VAL(io
.ntcreatex
.out
.create_action
, NTCREATEX_ACTION_CREATED
);
767 CHECK_NTTIME(io
.ntcreatex
.out
.create_time
, create_time
);
768 CHECK_NTTIME(io
.ntcreatex
.out
.access_time
, access_time
);
769 CHECK_NTTIME(io
.ntcreatex
.out
.write_time
, write_time
);
770 CHECK_NTTIME(io
.ntcreatex
.out
.change_time
, change_time
);
771 CHECK_ALL_INFO(io
.ntcreatex
.out
.attrib
, attrib
);
772 CHECK_ALL_INFO(io
.ntcreatex
.out
.alloc_size
, alloc_size
);
773 CHECK_ALL_INFO(io
.ntcreatex
.out
.size
, size
);
774 CHECK_ALL_INFO(io
.ntcreatex
.out
.is_directory
, directory
);
775 CHECK_VAL(io
.ntcreatex
.out
.file_type
, FILE_TYPE_DISK
);
777 /* check fields when the file already existed */
778 smbcli_close(cli
->tree
, fnum
);
779 smbcli_unlink(cli
->tree
, fname
);
780 fnum
= create_complex_file(cli
, tctx
, fname
);
785 smbcli_close(cli
->tree
, fnum
);
787 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OPEN
;
788 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
789 CHECK_STATUS(status
, NT_STATUS_OK
);
790 fnum
= io
.ntcreatex
.out
.file
.fnum
;
792 CHECK_VAL(io
.ntcreatex
.out
.oplock_level
, 0);
793 CHECK_VAL(io
.ntcreatex
.out
.create_action
, NTCREATEX_ACTION_EXISTED
);
794 CHECK_NTTIME(io
.ntcreatex
.out
.create_time
, create_time
);
795 CHECK_NTTIME(io
.ntcreatex
.out
.access_time
, access_time
);
796 CHECK_NTTIME(io
.ntcreatex
.out
.write_time
, write_time
);
797 CHECK_NTTIME(io
.ntcreatex
.out
.change_time
, change_time
);
798 CHECK_ALL_INFO(io
.ntcreatex
.out
.attrib
, attrib
);
799 CHECK_ALL_INFO(io
.ntcreatex
.out
.alloc_size
, alloc_size
);
800 CHECK_ALL_INFO(io
.ntcreatex
.out
.size
, size
);
801 CHECK_ALL_INFO(io
.ntcreatex
.out
.is_directory
, directory
);
802 CHECK_VAL(io
.ntcreatex
.out
.file_type
, FILE_TYPE_DISK
);
803 smbcli_close(cli
->tree
, fnum
);
804 smbcli_unlink(cli
->tree
, fname
);
807 /* create a directory */
808 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
809 io
.ntcreatex
.in
.access_mask
= SEC_RIGHTS_FILE_ALL
;
810 io
.ntcreatex
.in
.alloc_size
= 0;
811 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_DIRECTORY
;
812 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_NONE
;
813 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
814 io
.ntcreatex
.in
.create_options
= 0;
815 io
.ntcreatex
.in
.fname
= dname
;
818 smbcli_rmdir(cli
->tree
, fname
);
819 smbcli_unlink(cli
->tree
, fname
);
821 io
.ntcreatex
.in
.access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
822 io
.ntcreatex
.in
.create_options
= NTCREATEX_OPTIONS_DIRECTORY
;
823 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
824 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
| NTCREATEX_SHARE_ACCESS_WRITE
;
825 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
826 CHECK_STATUS(status
, NT_STATUS_OK
);
827 fnum
= io
.ntcreatex
.out
.file
.fnum
;
829 CHECK_VAL(io
.ntcreatex
.out
.oplock_level
, 0);
830 CHECK_VAL(io
.ntcreatex
.out
.create_action
, NTCREATEX_ACTION_CREATED
);
831 CHECK_NTTIME(io
.ntcreatex
.out
.create_time
, create_time
);
832 CHECK_NTTIME(io
.ntcreatex
.out
.access_time
, access_time
);
833 CHECK_NTTIME(io
.ntcreatex
.out
.write_time
, write_time
);
834 CHECK_NTTIME(io
.ntcreatex
.out
.change_time
, change_time
);
835 CHECK_ALL_INFO(io
.ntcreatex
.out
.attrib
, attrib
);
836 CHECK_VAL(io
.ntcreatex
.out
.attrib
& ~FILE_ATTRIBUTE_NONINDEXED
,
837 FILE_ATTRIBUTE_DIRECTORY
);
838 CHECK_ALL_INFO(io
.ntcreatex
.out
.alloc_size
, alloc_size
);
839 CHECK_ALL_INFO(io
.ntcreatex
.out
.size
, size
);
840 CHECK_ALL_INFO(io
.ntcreatex
.out
.is_directory
, directory
);
841 CHECK_VAL(io
.ntcreatex
.out
.is_directory
, 1);
842 CHECK_VAL(io
.ntcreatex
.out
.size
, 0);
843 CHECK_VAL(io
.ntcreatex
.out
.alloc_size
, 0);
844 CHECK_VAL(io
.ntcreatex
.out
.file_type
, FILE_TYPE_DISK
);
845 smbcli_unlink(cli
->tree
, fname
);
849 smbcli_close(cli
->tree
, fnum
);
850 smbcli_deltree(cli
->tree
, BASEDIR
);
857 test RAW_OPEN_NTTRANS_CREATE
859 static bool test_nttrans_create(struct torture_context
*tctx
, struct smbcli_state
*cli
)
862 union smb_fileinfo finfo
;
863 const char *fname
= BASEDIR
"\\torture_ntcreatex.txt";
864 const char *dname
= BASEDIR
"\\torture_ntcreatex.dir";
869 uint32_t ok_mask
, not_supported_mask
, invalid_parameter_mask
;
870 uint32_t not_a_directory_mask
, unexpected_mask
;
874 NTSTATUS correct_status
;
876 { NTCREATEX_DISP_SUPERSEDE
, true, NT_STATUS_OK
},
877 { NTCREATEX_DISP_SUPERSEDE
, false, NT_STATUS_OK
},
878 { NTCREATEX_DISP_OPEN
, true, NT_STATUS_OK
},
879 { NTCREATEX_DISP_OPEN
, false, NT_STATUS_OBJECT_NAME_NOT_FOUND
},
880 { NTCREATEX_DISP_CREATE
, true, NT_STATUS_OBJECT_NAME_COLLISION
},
881 { NTCREATEX_DISP_CREATE
, false, NT_STATUS_OK
},
882 { NTCREATEX_DISP_OPEN_IF
, true, NT_STATUS_OK
},
883 { NTCREATEX_DISP_OPEN_IF
, false, NT_STATUS_OK
},
884 { NTCREATEX_DISP_OVERWRITE
, true, NT_STATUS_OK
},
885 { NTCREATEX_DISP_OVERWRITE
, false, NT_STATUS_OBJECT_NAME_NOT_FOUND
},
886 { NTCREATEX_DISP_OVERWRITE_IF
, true, NT_STATUS_OK
},
887 { NTCREATEX_DISP_OVERWRITE_IF
, false, NT_STATUS_OK
},
888 { 6, true, NT_STATUS_INVALID_PARAMETER
},
889 { 6, false, NT_STATUS_INVALID_PARAMETER
},
892 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
894 /* reasonable default parameters */
895 io
.generic
.level
= RAW_OPEN_NTTRANS_CREATE
;
896 io
.ntcreatex
.in
.flags
= NTCREATEX_FLAGS_EXTENDED
;
897 io
.ntcreatex
.in
.root_fid
.fnum
= 0;
898 io
.ntcreatex
.in
.access_mask
= SEC_RIGHTS_FILE_ALL
;
899 io
.ntcreatex
.in
.alloc_size
= 1024*1024;
900 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
901 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_NONE
;
902 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
903 io
.ntcreatex
.in
.create_options
= 0;
904 io
.ntcreatex
.in
.impersonation
= NTCREATEX_IMPERSONATION_ANONYMOUS
;
905 io
.ntcreatex
.in
.security_flags
= 0;
906 io
.ntcreatex
.in
.fname
= fname
;
907 io
.ntcreatex
.in
.sec_desc
= NULL
;
908 io
.ntcreatex
.in
.ea_list
= NULL
;
910 /* test the open disposition */
911 for (i
=0; i
<ARRAY_SIZE(open_funcs
); i
++) {
912 if (open_funcs
[i
].with_file
) {
913 fnum
= smbcli_open(cli
->tree
, fname
, O_CREAT
|O_RDWR
|O_TRUNC
, DENY_NONE
);
915 torture_result(tctx
, TORTURE_FAIL
,
916 "Failed to create file %s - %s\n",
917 fname
, smbcli_errstr(cli
->tree
));
921 smbcli_close(cli
->tree
, fnum
);
923 io
.ntcreatex
.in
.open_disposition
= open_funcs
[i
].open_disp
;
924 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
925 if (!NT_STATUS_EQUAL(status
, open_funcs
[i
].correct_status
)) {
926 torture_result(tctx
, TORTURE_FAIL
,
927 "(%s) incorrect status %s should be %s "
928 "(i=%d with_file=%d open_disp=%d)\n",
929 __location__
, nt_errstr(status
),
930 nt_errstr(open_funcs
[i
].correct_status
),
931 i
, (int)open_funcs
[i
].with_file
,
932 (int)open_funcs
[i
].open_disp
);
935 if (NT_STATUS_IS_OK(status
) || open_funcs
[i
].with_file
) {
936 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
937 smbcli_unlink(cli
->tree
, fname
);
941 /* basic field testing */
942 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
944 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
945 CHECK_STATUS(status
, NT_STATUS_OK
);
946 fnum
= io
.ntcreatex
.out
.file
.fnum
;
948 CHECK_VAL(io
.ntcreatex
.out
.oplock_level
, 0);
949 CHECK_VAL(io
.ntcreatex
.out
.create_action
, NTCREATEX_ACTION_CREATED
);
950 CHECK_NTTIME(io
.ntcreatex
.out
.create_time
, create_time
);
951 CHECK_NTTIME(io
.ntcreatex
.out
.access_time
, access_time
);
952 CHECK_NTTIME(io
.ntcreatex
.out
.write_time
, write_time
);
953 CHECK_NTTIME(io
.ntcreatex
.out
.change_time
, change_time
);
954 CHECK_ALL_INFO(io
.ntcreatex
.out
.attrib
, attrib
);
955 CHECK_ALL_INFO(io
.ntcreatex
.out
.alloc_size
, alloc_size
);
956 CHECK_ALL_INFO(io
.ntcreatex
.out
.size
, size
);
957 CHECK_ALL_INFO(io
.ntcreatex
.out
.is_directory
, directory
);
958 CHECK_VAL(io
.ntcreatex
.out
.file_type
, FILE_TYPE_DISK
);
960 /* check fields when the file already existed */
961 smbcli_close(cli
->tree
, fnum
);
962 smbcli_unlink(cli
->tree
, fname
);
963 fnum
= create_complex_file(cli
, tctx
, fname
);
968 smbcli_close(cli
->tree
, fnum
);
970 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OPEN
;
971 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
972 CHECK_STATUS(status
, NT_STATUS_OK
);
973 fnum
= io
.ntcreatex
.out
.file
.fnum
;
975 CHECK_VAL(io
.ntcreatex
.out
.oplock_level
, 0);
976 CHECK_VAL(io
.ntcreatex
.out
.create_action
, NTCREATEX_ACTION_EXISTED
);
977 CHECK_NTTIME(io
.ntcreatex
.out
.create_time
, create_time
);
978 CHECK_NTTIME(io
.ntcreatex
.out
.access_time
, access_time
);
979 CHECK_NTTIME(io
.ntcreatex
.out
.write_time
, write_time
);
980 CHECK_NTTIME(io
.ntcreatex
.out
.change_time
, change_time
);
981 CHECK_ALL_INFO(io
.ntcreatex
.out
.attrib
, attrib
);
982 CHECK_ALL_INFO(io
.ntcreatex
.out
.alloc_size
, alloc_size
);
983 CHECK_ALL_INFO(io
.ntcreatex
.out
.size
, size
);
984 CHECK_ALL_INFO(io
.ntcreatex
.out
.is_directory
, directory
);
985 CHECK_VAL(io
.ntcreatex
.out
.file_type
, FILE_TYPE_DISK
);
986 smbcli_close(cli
->tree
, fnum
);
988 /* check no-recall - don't pull a file from tape on a HSM */
989 io
.ntcreatex
.in
.create_options
= NTCREATEX_OPTIONS_NO_RECALL
;
990 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
991 CHECK_STATUS(status
, NT_STATUS_OK
);
992 fnum
= io
.ntcreatex
.out
.file
.fnum
;
994 CHECK_VAL(io
.ntcreatex
.out
.oplock_level
, 0);
995 CHECK_VAL(io
.ntcreatex
.out
.create_action
, NTCREATEX_ACTION_EXISTED
);
996 CHECK_NTTIME(io
.ntcreatex
.out
.create_time
, create_time
);
997 CHECK_NTTIME(io
.ntcreatex
.out
.access_time
, access_time
);
998 CHECK_NTTIME(io
.ntcreatex
.out
.write_time
, write_time
);
999 CHECK_NTTIME(io
.ntcreatex
.out
.change_time
, change_time
);
1000 CHECK_ALL_INFO(io
.ntcreatex
.out
.attrib
, attrib
);
1001 CHECK_ALL_INFO(io
.ntcreatex
.out
.alloc_size
, alloc_size
);
1002 CHECK_ALL_INFO(io
.ntcreatex
.out
.size
, size
);
1003 CHECK_ALL_INFO(io
.ntcreatex
.out
.is_directory
, directory
);
1004 CHECK_VAL(io
.ntcreatex
.out
.file_type
, FILE_TYPE_DISK
);
1005 smbcli_close(cli
->tree
, fnum
);
1007 /* Check some create options (these all should be ignored) */
1008 for (i
=0; i
< 32; i
++) {
1009 uint32_t create_option
= (1 << i
) & NTCREATEX_OPTIONS_MUST_IGNORE_MASK
;
1010 if (create_option
== 0) {
1013 io
.ntcreatex
.in
.create_options
= create_option
;
1014 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1015 if (!NT_STATUS_IS_OK(status
)) {
1016 torture_warning(tctx
, "ntcreatex create option 0x%08x "
1017 "gave %s - should give NT_STATUS_OK\n",
1018 create_option
, nt_errstr(status
));
1020 CHECK_STATUS(status
, NT_STATUS_OK
);
1021 fnum
= io
.ntcreatex
.out
.file
.fnum
;
1023 CHECK_VAL(io
.ntcreatex
.out
.oplock_level
, 0);
1024 CHECK_VAL(io
.ntcreatex
.out
.create_action
, NTCREATEX_ACTION_EXISTED
);
1025 CHECK_NTTIME(io
.ntcreatex
.out
.create_time
, create_time
);
1026 CHECK_NTTIME(io
.ntcreatex
.out
.access_time
, access_time
);
1027 CHECK_NTTIME(io
.ntcreatex
.out
.write_time
, write_time
);
1028 CHECK_NTTIME(io
.ntcreatex
.out
.change_time
, change_time
);
1029 CHECK_ALL_INFO(io
.ntcreatex
.out
.attrib
, attrib
);
1030 CHECK_ALL_INFO(io
.ntcreatex
.out
.alloc_size
, alloc_size
);
1031 CHECK_ALL_INFO(io
.ntcreatex
.out
.size
, size
);
1032 CHECK_ALL_INFO(io
.ntcreatex
.out
.is_directory
, directory
);
1033 CHECK_VAL(io
.ntcreatex
.out
.file_type
, FILE_TYPE_DISK
);
1034 smbcli_close(cli
->tree
, fnum
);
1037 io
.ntcreatex
.in
.file_attr
= 0;
1038 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OPEN_IF
;
1039 io
.ntcreatex
.in
.access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
1041 /* Check for options that should return NOT_SUPPORTED, OK or INVALID_PARAMETER */
1043 not_supported_mask
= 0;
1044 invalid_parameter_mask
= 0;
1045 not_a_directory_mask
= 0;
1046 unexpected_mask
= 0;
1047 for (i
=0; i
< 32; i
++) {
1048 uint32_t create_option
= 1<<i
;
1049 if (create_option
& NTCREATEX_OPTIONS_DELETE_ON_CLOSE
) {
1052 io
.ntcreatex
.in
.create_options
= create_option
;
1053 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1054 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_SUPPORTED
)) {
1055 not_supported_mask
|= create_option
;
1056 } else if (NT_STATUS_EQUAL(status
, NT_STATUS_OK
)) {
1057 ok_mask
|= create_option
;
1058 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
1059 } else if (NT_STATUS_EQUAL(status
, NT_STATUS_INVALID_PARAMETER
)) {
1060 invalid_parameter_mask
|= create_option
;
1061 } else if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_A_DIRECTORY
)) {
1062 not_a_directory_mask
|= 1<<i
;
1064 unexpected_mask
|= 1<<i
;
1065 torture_comment(tctx
, "create option 0x%08x returned %s\n",
1066 create_option
, nt_errstr(status
));
1070 CHECK_VAL(ok_mask
, 0x00efcfce);
1071 CHECK_VAL(not_a_directory_mask
, 0x00000001);
1072 CHECK_VAL(not_supported_mask
, 0x00002000);
1073 CHECK_VAL(invalid_parameter_mask
, 0xff100030);
1074 CHECK_VAL(unexpected_mask
, 0x00000000);
1076 smbcli_unlink(cli
->tree
, fname
);
1079 /* create a directory */
1080 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
1081 io
.ntcreatex
.in
.access_mask
= SEC_RIGHTS_FILE_ALL
;
1082 io
.ntcreatex
.in
.alloc_size
= 0;
1083 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_DIRECTORY
;
1084 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_NONE
;
1085 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
1086 io
.ntcreatex
.in
.create_options
= 0;
1087 io
.ntcreatex
.in
.fname
= dname
;
1090 smbcli_rmdir(cli
->tree
, fname
);
1091 smbcli_unlink(cli
->tree
, fname
);
1093 io
.ntcreatex
.in
.access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
1094 io
.ntcreatex
.in
.create_options
= NTCREATEX_OPTIONS_DIRECTORY
;
1095 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
1096 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
| NTCREATEX_SHARE_ACCESS_WRITE
;
1097 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1098 CHECK_STATUS(status
, NT_STATUS_OK
);
1099 fnum
= io
.ntcreatex
.out
.file
.fnum
;
1101 CHECK_VAL(io
.ntcreatex
.out
.oplock_level
, 0);
1102 CHECK_VAL(io
.ntcreatex
.out
.create_action
, NTCREATEX_ACTION_CREATED
);
1103 CHECK_NTTIME(io
.ntcreatex
.out
.create_time
, create_time
);
1104 CHECK_NTTIME(io
.ntcreatex
.out
.access_time
, access_time
);
1105 CHECK_NTTIME(io
.ntcreatex
.out
.write_time
, write_time
);
1106 CHECK_NTTIME(io
.ntcreatex
.out
.change_time
, change_time
);
1107 CHECK_ALL_INFO(io
.ntcreatex
.out
.attrib
, attrib
);
1108 CHECK_VAL(io
.ntcreatex
.out
.attrib
& ~FILE_ATTRIBUTE_NONINDEXED
,
1109 FILE_ATTRIBUTE_DIRECTORY
);
1110 CHECK_ALL_INFO(io
.ntcreatex
.out
.alloc_size
, alloc_size
);
1111 CHECK_ALL_INFO(io
.ntcreatex
.out
.size
, size
);
1112 CHECK_ALL_INFO(io
.ntcreatex
.out
.is_directory
, directory
);
1113 CHECK_VAL(io
.ntcreatex
.out
.is_directory
, 1);
1114 CHECK_VAL(io
.ntcreatex
.out
.size
, 0);
1115 CHECK_VAL(io
.ntcreatex
.out
.alloc_size
, 0);
1116 CHECK_VAL(io
.ntcreatex
.out
.file_type
, FILE_TYPE_DISK
);
1117 smbcli_unlink(cli
->tree
, fname
);
1121 smbcli_close(cli
->tree
, fnum
);
1122 smbcli_deltree(cli
->tree
, BASEDIR
);
1128 test RAW_OPEN_NTCREATEX with an already opened and byte range locked file
1130 I've got an application that does a similar sequence of ntcreate&x,
1131 locking&x and another ntcreate&x with
1132 open_disposition==NTCREATEX_DISP_OVERWRITE_IF. Windows 2003 allows the
1135 static bool test_ntcreatex_brlocked(struct torture_context
*tctx
, struct smbcli_state
*cli
)
1137 union smb_open io
, io1
;
1139 struct smb_lock_entry lock
[1];
1140 const char *fname
= BASEDIR
"\\torture_ntcreatex.txt";
1144 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1146 torture_comment(tctx
, "Testing ntcreatex with a byte range locked file\n");
1148 io
.generic
.level
= RAW_OPEN_NTCREATEX
;
1149 io
.ntcreatex
.in
.flags
= NTCREATEX_FLAGS_EXTENDED
;
1150 io
.ntcreatex
.in
.root_fid
.fnum
= 0;
1151 io
.ntcreatex
.in
.access_mask
= 0x2019f;
1152 io
.ntcreatex
.in
.alloc_size
= 0;
1153 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
1154 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
|
1155 NTCREATEX_SHARE_ACCESS_WRITE
;
1156 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
1157 io
.ntcreatex
.in
.create_options
= NTCREATEX_OPTIONS_NON_DIRECTORY_FILE
;
1158 io
.ntcreatex
.in
.impersonation
= NTCREATEX_IMPERSONATION_IMPERSONATION
;
1159 io
.ntcreatex
.in
.security_flags
= NTCREATEX_SECURITY_DYNAMIC
|
1160 NTCREATEX_SECURITY_ALL
;
1161 io
.ntcreatex
.in
.fname
= fname
;
1163 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1164 CHECK_STATUS(status
, NT_STATUS_OK
);
1166 io2
.lockx
.level
= RAW_LOCK_LOCKX
;
1167 io2
.lockx
.in
.file
.fnum
= io
.ntcreatex
.out
.file
.fnum
;
1168 io2
.lockx
.in
.mode
= LOCKING_ANDX_LARGE_FILES
;
1169 io2
.lockx
.in
.timeout
= 0;
1170 io2
.lockx
.in
.ulock_cnt
= 0;
1171 io2
.lockx
.in
.lock_cnt
= 1;
1172 lock
[0].pid
= cli
->session
->pid
;
1174 lock
[0].count
= 0x1;
1175 io2
.lockx
.in
.locks
= &lock
[0];
1176 status
= smb_raw_lock(cli
->tree
, &io2
);
1177 CHECK_STATUS(status
, NT_STATUS_OK
);
1179 io1
.generic
.level
= RAW_OPEN_NTCREATEX
;
1180 io1
.ntcreatex
.in
.flags
= NTCREATEX_FLAGS_EXTENDED
;
1181 io1
.ntcreatex
.in
.root_fid
.fnum
= 0;
1182 io1
.ntcreatex
.in
.access_mask
= 0x20196;
1183 io1
.ntcreatex
.in
.alloc_size
= 0;
1184 io1
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
1185 io1
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
|
1186 NTCREATEX_SHARE_ACCESS_WRITE
;
1187 io1
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OVERWRITE_IF
;
1188 io1
.ntcreatex
.in
.create_options
= 0;
1189 io1
.ntcreatex
.in
.impersonation
= NTCREATEX_IMPERSONATION_IMPERSONATION
;
1190 io1
.ntcreatex
.in
.security_flags
= NTCREATEX_SECURITY_DYNAMIC
|
1191 NTCREATEX_SECURITY_ALL
;
1192 io1
.ntcreatex
.in
.fname
= fname
;
1194 status
= smb_raw_open(cli
->tree
, tctx
, &io1
);
1195 CHECK_STATUS(status
, NT_STATUS_OK
);
1198 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
1199 smbcli_close(cli
->tree
, io1
.ntcreatex
.out
.file
.fnum
);
1200 smbcli_deltree(cli
->tree
, BASEDIR
);
1207 static bool test_mknew(struct torture_context
*tctx
, struct smbcli_state
*cli
)
1210 const char *fname
= BASEDIR
"\\torture_mknew.txt";
1214 time_t basetime
= (time(NULL
) + 3600*24*3) & ~1;
1215 union smb_fileinfo finfo
;
1217 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1219 io
.mknew
.level
= RAW_OPEN_MKNEW
;
1220 io
.mknew
.in
.attrib
= 0;
1221 io
.mknew
.in
.write_time
= 0;
1222 io
.mknew
.in
.fname
= fname
;
1223 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1224 CHECK_STATUS(status
, NT_STATUS_OK
);
1225 fnum
= io
.mknew
.out
.file
.fnum
;
1227 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1228 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_COLLISION
);
1230 smbcli_close(cli
->tree
, fnum
);
1231 smbcli_unlink(cli
->tree
, fname
);
1233 /* make sure write_time works */
1234 io
.mknew
.in
.write_time
= basetime
;
1235 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1236 CHECK_STATUS(status
, NT_STATUS_OK
);
1237 fnum
= io
.mknew
.out
.file
.fnum
;
1238 CHECK_TIME(basetime
, write_time
);
1240 smbcli_close(cli
->tree
, fnum
);
1241 smbcli_unlink(cli
->tree
, fname
);
1243 /* make sure file_attrs works */
1244 io
.mknew
.in
.attrib
= FILE_ATTRIBUTE_HIDDEN
;
1245 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1246 CHECK_STATUS(status
, NT_STATUS_OK
);
1247 fnum
= io
.mknew
.out
.file
.fnum
;
1248 CHECK_ALL_INFO(FILE_ATTRIBUTE_HIDDEN
| FILE_ATTRIBUTE_ARCHIVE
,
1249 attrib
& ~FILE_ATTRIBUTE_NONINDEXED
);
1252 smbcli_close(cli
->tree
, fnum
);
1253 smbcli_deltree(cli
->tree
, BASEDIR
);
1260 test RAW_OPEN_CREATE
1262 static bool test_create(struct torture_context
*tctx
, struct smbcli_state
*cli
)
1265 const char *fname
= BASEDIR
"\\torture_create.txt";
1269 time_t basetime
= (time(NULL
) + 3600*24*3) & ~1;
1270 union smb_fileinfo finfo
;
1272 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1274 io
.create
.level
= RAW_OPEN_CREATE
;
1275 io
.create
.in
.attrib
= 0;
1276 io
.create
.in
.write_time
= 0;
1277 io
.create
.in
.fname
= fname
;
1278 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1279 CHECK_STATUS(status
, NT_STATUS_OK
);
1280 fnum
= io
.create
.out
.file
.fnum
;
1282 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1283 CHECK_STATUS(status
, NT_STATUS_OK
);
1285 smbcli_close(cli
->tree
, io
.create
.out
.file
.fnum
);
1286 smbcli_close(cli
->tree
, fnum
);
1287 smbcli_unlink(cli
->tree
, fname
);
1289 /* make sure write_time works */
1290 io
.create
.in
.write_time
= basetime
;
1291 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1292 CHECK_STATUS(status
, NT_STATUS_OK
);
1293 fnum
= io
.create
.out
.file
.fnum
;
1294 CHECK_TIME(basetime
, write_time
);
1296 smbcli_close(cli
->tree
, fnum
);
1297 smbcli_unlink(cli
->tree
, fname
);
1299 /* make sure file_attrs works */
1300 io
.create
.in
.attrib
= FILE_ATTRIBUTE_HIDDEN
;
1301 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1302 CHECK_STATUS(status
, NT_STATUS_OK
);
1303 fnum
= io
.create
.out
.file
.fnum
;
1304 CHECK_ALL_INFO(FILE_ATTRIBUTE_HIDDEN
| FILE_ATTRIBUTE_ARCHIVE
,
1305 attrib
& ~FILE_ATTRIBUTE_NONINDEXED
);
1308 smbcli_close(cli
->tree
, fnum
);
1309 smbcli_deltree(cli
->tree
, BASEDIR
);
1318 static bool test_ctemp(struct torture_context
*tctx
, struct smbcli_state
*cli
)
1324 time_t basetime
= (time(NULL
) + 3600*24*3) & ~1;
1325 union smb_fileinfo finfo
;
1326 const char *name
, *fname
= NULL
;
1328 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1330 io
.ctemp
.level
= RAW_OPEN_CTEMP
;
1331 io
.ctemp
.in
.attrib
= FILE_ATTRIBUTE_HIDDEN
;
1332 io
.ctemp
.in
.write_time
= basetime
;
1333 io
.ctemp
.in
.directory
= BASEDIR
;
1334 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1335 CHECK_STATUS(status
, NT_STATUS_OK
);
1336 fnum
= io
.ctemp
.out
.file
.fnum
;
1338 name
= io
.ctemp
.out
.name
;
1340 finfo
.generic
.level
= RAW_FILEINFO_NAME_INFO
;
1341 finfo
.generic
.in
.file
.fnum
= fnum
;
1342 status
= smb_raw_fileinfo(cli
->tree
, tctx
, &finfo
);
1343 CHECK_STATUS(status
, NT_STATUS_OK
);
1345 fname
= finfo
.name_info
.out
.fname
.s
;
1346 torture_comment(tctx
, "ctemp name=%s real name=%s\n", name
, fname
);
1349 smbcli_close(cli
->tree
, fnum
);
1350 smbcli_deltree(cli
->tree
, BASEDIR
);
1357 test chained RAW_OPEN_OPENX_READX
1359 static bool test_chained(struct torture_context
*tctx
, struct smbcli_state
*cli
)
1362 const char *fname
= BASEDIR
"\\torture_chained.txt";
1366 const char *buf
= "test";
1369 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1371 fnum
= create_complex_file(cli
, tctx
, fname
);
1373 smbcli_write(cli
->tree
, fnum
, 0, buf
, 0, sizeof(buf
));
1375 smbcli_close(cli
->tree
, fnum
);
1377 io
.openxreadx
.level
= RAW_OPEN_OPENX_READX
;
1378 io
.openxreadx
.in
.fname
= fname
;
1379 io
.openxreadx
.in
.flags
= OPENX_FLAGS_ADDITIONAL_INFO
;
1380 io
.openxreadx
.in
.open_mode
= OPENX_MODE_ACCESS_RDWR
;
1381 io
.openxreadx
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
;
1382 io
.openxreadx
.in
.search_attrs
= 0;
1383 io
.openxreadx
.in
.file_attrs
= 0;
1384 io
.openxreadx
.in
.write_time
= 0;
1385 io
.openxreadx
.in
.size
= 1024*1024;
1386 io
.openxreadx
.in
.timeout
= 0;
1388 io
.openxreadx
.in
.offset
= 0;
1389 io
.openxreadx
.in
.mincnt
= sizeof(buf
);
1390 io
.openxreadx
.in
.maxcnt
= sizeof(buf
);
1391 io
.openxreadx
.in
.remaining
= 0;
1392 io
.openxreadx
.out
.data
= (uint8_t *)buf2
;
1394 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1395 CHECK_STATUS(status
, NT_STATUS_OK
);
1396 fnum
= io
.openxreadx
.out
.file
.fnum
;
1398 if (memcmp(buf
, buf2
, MIN(sizeof(buf
), sizeof(buf2
))) != 0) {
1399 torture_result(tctx
, TORTURE_FAIL
,
1400 "wrong data in reply buffer\n");
1405 smbcli_close(cli
->tree
, fnum
);
1406 smbcli_deltree(cli
->tree
, BASEDIR
);
1412 test RAW_OPEN_OPENX without a leading slash on the path.
1413 NetApp filers are known to fail on this.
1416 static bool test_no_leading_slash(struct torture_context
*tctx
, struct smbcli_state
*cli
)
1419 const char *fname
= BASEDIR
"\\torture_no_leading_slash.txt";
1423 const char *buf
= "test";
1425 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1427 smbcli_unlink(cli
->tree
, fname
);
1429 /* Create the file */
1430 fnum
= create_complex_file(cli
, tctx
, fname
);
1431 smbcli_write(cli
->tree
, fnum
, 0, buf
, 0, sizeof(buf
));
1432 smbcli_close(cli
->tree
, fnum
);
1434 /* Prepare to open the file using path without leading slash */
1435 io
.openx
.level
= RAW_OPEN_OPENX
;
1436 io
.openx
.in
.fname
= fname
+ 1;
1437 io
.openx
.in
.flags
= OPENX_FLAGS_ADDITIONAL_INFO
;
1438 io
.openx
.in
.open_mode
= OPENX_MODE_ACCESS_RDWR
;
1439 io
.openx
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
;
1440 io
.openx
.in
.search_attrs
= 0;
1441 io
.openx
.in
.file_attrs
= 0;
1442 io
.openx
.in
.write_time
= 0;
1443 io
.openx
.in
.size
= 1024*1024;
1444 io
.openx
.in
.timeout
= 0;
1446 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1447 CHECK_STATUS(status
, NT_STATUS_OK
);
1448 fnum
= io
.openx
.out
.file
.fnum
;
1451 smbcli_close(cli
->tree
, fnum
);
1452 smbcli_deltree(cli
->tree
, BASEDIR
);
1458 test RAW_OPEN_OPENX against an existing directory to
1459 ensure it returns NT_STATUS_FILE_IS_A_DIRECTORY.
1460 Samba 3.2.0 - 3.2.6 are known to fail this.
1463 static bool test_openx_over_dir(struct torture_context
*tctx
, struct smbcli_state
*cli
)
1466 const char *fname
= BASEDIR
"\\openx_over_dir";
1472 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1474 /* Create the Directory */
1475 status
= create_directory_handle(cli
->tree
, fname
, &d_fnum
);
1476 smbcli_close(cli
->tree
, d_fnum
);
1478 /* Prepare to open the file over the directory. */
1479 io
.openx
.level
= RAW_OPEN_OPENX
;
1480 io
.openx
.in
.fname
= fname
;
1481 io
.openx
.in
.flags
= OPENX_FLAGS_ADDITIONAL_INFO
;
1482 io
.openx
.in
.open_mode
= OPENX_MODE_ACCESS_RDWR
;
1483 io
.openx
.in
.open_func
= OPENX_OPEN_FUNC_OPEN
;
1484 io
.openx
.in
.search_attrs
= 0;
1485 io
.openx
.in
.file_attrs
= 0;
1486 io
.openx
.in
.write_time
= 0;
1487 io
.openx
.in
.size
= 1024*1024;
1488 io
.openx
.in
.timeout
= 0;
1490 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1491 CHECK_STATUS(status
, NT_STATUS_FILE_IS_A_DIRECTORY
);
1492 fnum
= io
.openx
.out
.file
.fnum
;
1495 smbcli_close(cli
->tree
, fnum
);
1496 smbcli_deltree(cli
->tree
, BASEDIR
);
1502 /* A little torture test to expose a race condition in Samba 3.0.20 ... :-) */
1504 static bool test_raw_open_multi(struct torture_context
*tctx
, struct smbcli_state
*cli_ignored
)
1506 struct smbcli_state
*cli
;
1507 TALLOC_CTX
*mem_ctx
= talloc_init("torture_test_oplock_multi");
1508 const char *fname
= "\\test_oplock.dat";
1512 struct smbcli_state
**clients
;
1513 struct smbcli_request
**requests
;
1514 union smb_open
*ios
;
1515 const char *host
= torture_setting_string(tctx
, "host", NULL
);
1516 const char *share
= torture_setting_string(tctx
, "share", NULL
);
1517 int i
, num_files
= 3;
1519 int num_collision
= 0;
1521 clients
= talloc_array(mem_ctx
, struct smbcli_state
*, num_files
);
1522 requests
= talloc_array(mem_ctx
, struct smbcli_request
*, num_files
);
1523 ios
= talloc_array(mem_ctx
, union smb_open
, num_files
);
1524 if ((tctx
->ev
== NULL
) || (clients
== NULL
) || (requests
== NULL
) ||
1526 torture_result(tctx
, TORTURE_FAIL
, "(%s): talloc failed\n",
1531 if (!torture_open_connection_share(mem_ctx
, &cli
, tctx
, host
, share
, tctx
->ev
)) {
1535 cli
->tree
->session
->transport
->options
.request_timeout
= 60;
1537 for (i
=0; i
<num_files
; i
++) {
1538 if (!torture_open_connection_share(mem_ctx
, &(clients
[i
]),
1539 tctx
, host
, share
, tctx
->ev
)) {
1540 torture_result(tctx
, TORTURE_FAIL
,
1541 "(%s): Could not open %d'th connection\n",
1545 clients
[i
]->tree
->session
->transport
->options
.request_timeout
= 60;
1549 smbcli_unlink(cli
->tree
, fname
);
1552 base ntcreatex parms
1554 io
.generic
.level
= RAW_OPEN_NTCREATEX
;
1555 io
.ntcreatex
.in
.root_fid
.fnum
= 0;
1556 io
.ntcreatex
.in
.access_mask
= SEC_RIGHTS_FILE_ALL
;
1557 io
.ntcreatex
.in
.alloc_size
= 0;
1558 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
1559 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
|
1560 NTCREATEX_SHARE_ACCESS_WRITE
|
1561 NTCREATEX_SHARE_ACCESS_DELETE
;
1562 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
1563 io
.ntcreatex
.in
.create_options
= 0;
1564 io
.ntcreatex
.in
.impersonation
= NTCREATEX_IMPERSONATION_ANONYMOUS
;
1565 io
.ntcreatex
.in
.security_flags
= 0;
1566 io
.ntcreatex
.in
.fname
= fname
;
1567 io
.ntcreatex
.in
.flags
= 0;
1569 for (i
=0; i
<num_files
; i
++) {
1571 requests
[i
] = smb_raw_open_send(clients
[i
]->tree
, &ios
[i
]);
1572 if (requests
[i
] == NULL
) {
1573 torture_result(tctx
, TORTURE_FAIL
,
1574 "(%s): could not send %d'th request\n",
1580 torture_comment(tctx
, "waiting for replies\n");
1582 bool unreplied
= false;
1583 for (i
=0; i
<num_files
; i
++) {
1584 if (requests
[i
] == NULL
) {
1587 if (requests
[i
]->state
< SMBCLI_REQUEST_DONE
) {
1591 status
= smb_raw_open_recv(requests
[i
], mem_ctx
,
1594 torture_comment(tctx
, "File %d returned status %s\n", i
,
1597 if (NT_STATUS_IS_OK(status
)) {
1601 if (NT_STATUS_EQUAL(status
,
1602 NT_STATUS_OBJECT_NAME_COLLISION
)) {
1612 if (tevent_loop_once(tctx
->ev
) != 0) {
1613 torture_result(tctx
, TORTURE_FAIL
,
1614 "(%s): tevent_loop_once failed\n", __location__
);
1619 if ((num_ok
!= 1) || (num_ok
+ num_collision
!= num_files
)) {
1623 for (i
=0; i
<num_files
; i
++) {
1624 torture_close_connection(clients
[i
]);
1626 talloc_free(mem_ctx
);
1631 test opening for delete on a read-only attribute file.
1633 static bool test_open_for_delete(struct torture_context
*tctx
, struct smbcli_state
*cli
)
1636 union smb_fileinfo finfo
;
1637 const char *fname
= BASEDIR
"\\torture_open_for_delete.txt";
1642 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1644 /* reasonable default parameters */
1645 io
.generic
.level
= RAW_OPEN_NTCREATEX
;
1646 io
.ntcreatex
.in
.flags
= NTCREATEX_FLAGS_EXTENDED
;
1647 io
.ntcreatex
.in
.root_fid
.fnum
= 0;
1648 io
.ntcreatex
.in
.alloc_size
= 0;
1649 io
.ntcreatex
.in
.access_mask
= SEC_RIGHTS_FILE_ALL
;
1650 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_READONLY
;
1651 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_NONE
;
1652 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
1653 io
.ntcreatex
.in
.create_options
= 0;
1654 io
.ntcreatex
.in
.impersonation
= NTCREATEX_IMPERSONATION_ANONYMOUS
;
1655 io
.ntcreatex
.in
.security_flags
= 0;
1656 io
.ntcreatex
.in
.fname
= fname
;
1658 /* Create the readonly file. */
1660 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1661 CHECK_STATUS(status
, NT_STATUS_OK
);
1662 fnum
= io
.ntcreatex
.out
.file
.fnum
;
1664 CHECK_VAL(io
.ntcreatex
.out
.oplock_level
, 0);
1665 io
.ntcreatex
.in
.create_options
= 0;
1666 CHECK_VAL(io
.ntcreatex
.out
.create_action
, NTCREATEX_ACTION_CREATED
);
1667 CHECK_ALL_INFO(io
.ntcreatex
.out
.attrib
, attrib
);
1668 smbcli_close(cli
->tree
, fnum
);
1670 /* Now try and open for delete only - should succeed. */
1671 io
.ntcreatex
.in
.access_mask
= SEC_STD_DELETE
;
1672 io
.ntcreatex
.in
.file_attr
= 0;
1673 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
| NTCREATEX_SHARE_ACCESS_WRITE
| NTCREATEX_SHARE_ACCESS_DELETE
;
1674 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OPEN
;
1675 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1676 CHECK_STATUS(status
, NT_STATUS_OK
);
1678 smbcli_unlink(cli
->tree
, fname
);
1681 smbcli_close(cli
->tree
, fnum
);
1682 smbcli_deltree(cli
->tree
, BASEDIR
);
1688 test chained RAW_OPEN_NTCREATEX_READX
1689 Send chained NTCREATEX_READX on a file that doesn't exist, then create
1690 the file and try again.
1692 static bool test_chained_ntcreatex_readx(struct torture_context
*tctx
, struct smbcli_state
*cli
)
1694 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1696 const char *fname
= BASEDIR
"\\torture_chained.txt";
1700 const char *buf
= "test";
1703 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1705 torture_comment(tctx
, "Checking RAW_NTCREATEX_READX chained on "
1706 "non-existent file \n");
1708 /* ntcreatex parameters */
1709 io
.generic
.level
= RAW_OPEN_NTCREATEX_READX
;
1710 io
.ntcreatexreadx
.in
.flags
= 0;
1711 io
.ntcreatexreadx
.in
.root_fid
.fnum
= 0;
1712 io
.ntcreatexreadx
.in
.access_mask
= SEC_FILE_READ_DATA
;
1713 io
.ntcreatexreadx
.in
.alloc_size
= 0;
1714 io
.ntcreatexreadx
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
1715 io
.ntcreatexreadx
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
|
1716 NTCREATEX_SHARE_ACCESS_WRITE
| NTCREATEX_SHARE_ACCESS_DELETE
;
1717 io
.ntcreatexreadx
.in
.open_disposition
= NTCREATEX_DISP_OPEN
;
1718 io
.ntcreatexreadx
.in
.create_options
= 0;
1719 io
.ntcreatexreadx
.in
.impersonation
= NTCREATEX_IMPERSONATION_IMPERSONATION
;
1720 io
.ntcreatexreadx
.in
.security_flags
= 0;
1721 io
.ntcreatexreadx
.in
.fname
= fname
;
1723 /* readx parameters */
1724 io
.ntcreatexreadx
.in
.offset
= 0;
1725 io
.ntcreatexreadx
.in
.mincnt
= sizeof(buf
);
1726 io
.ntcreatexreadx
.in
.maxcnt
= sizeof(buf
);
1727 io
.ntcreatexreadx
.in
.remaining
= 0;
1728 io
.ntcreatexreadx
.out
.data
= (uint8_t *)buf2
;
1730 /* try to open the non-existent file */
1731 status
= smb_raw_open(cli
->tree
, mem_ctx
, &io
);
1732 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
1733 fnum
= io
.ntcreatexreadx
.out
.file
.fnum
;
1735 smbcli_close(cli
->tree
, fnum
);
1736 smbcli_unlink(cli
->tree
, fname
);
1738 torture_comment(tctx
, "Checking RAW_NTCREATEX_READX chained on "
1739 "existing file \n");
1741 fnum
= create_complex_file(cli
, mem_ctx
, fname
);
1742 smbcli_write(cli
->tree
, fnum
, 0, buf
, 0, sizeof(buf
));
1743 smbcli_close(cli
->tree
, fnum
);
1745 status
= smb_raw_open(cli
->tree
, mem_ctx
, &io
);
1746 CHECK_STATUS(status
, NT_STATUS_OK
);
1747 fnum
= io
.ntcreatexreadx
.out
.file
.fnum
;
1749 if (memcmp(buf
, buf2
, MIN(sizeof(buf
), sizeof(buf2
))) != 0) {
1750 torture_result(tctx
, TORTURE_FAIL
,
1751 "(%s): wrong data in reply buffer\n", __location__
);
1756 smbcli_close(cli
->tree
, fnum
);
1757 smbcli_deltree(cli
->tree
, BASEDIR
);
1758 talloc_free(mem_ctx
);
1763 static bool test_ntcreatex_opendisp_dir(struct torture_context
*tctx
,
1764 struct smbcli_state
*cli
)
1766 const char *dname
= BASEDIR
"\\torture_ntcreatex_opendisp_dir";
1773 NTSTATUS correct_status
;
1774 } open_funcs_dir
[] = {
1775 { NTCREATEX_DISP_SUPERSEDE
, true, NT_STATUS_INVALID_PARAMETER
},
1776 { NTCREATEX_DISP_SUPERSEDE
, false, NT_STATUS_INVALID_PARAMETER
},
1777 { NTCREATEX_DISP_OPEN
, true, NT_STATUS_OK
},
1778 { NTCREATEX_DISP_OPEN
, false, NT_STATUS_OBJECT_NAME_NOT_FOUND
},
1779 { NTCREATEX_DISP_CREATE
, true, NT_STATUS_OBJECT_NAME_COLLISION
},
1780 { NTCREATEX_DISP_CREATE
, false, NT_STATUS_OK
},
1781 { NTCREATEX_DISP_OPEN_IF
, true, NT_STATUS_OK
},
1782 { NTCREATEX_DISP_OPEN_IF
, false, NT_STATUS_OK
},
1783 { NTCREATEX_DISP_OVERWRITE
, true, NT_STATUS_INVALID_PARAMETER
},
1784 { NTCREATEX_DISP_OVERWRITE
, false, NT_STATUS_INVALID_PARAMETER
},
1785 { NTCREATEX_DISP_OVERWRITE_IF
, true, NT_STATUS_INVALID_PARAMETER
},
1786 { NTCREATEX_DISP_OVERWRITE_IF
, false, NT_STATUS_INVALID_PARAMETER
},
1787 { 6, true, NT_STATUS_INVALID_PARAMETER
},
1788 { 6, false, NT_STATUS_INVALID_PARAMETER
},
1793 io
.generic
.level
= RAW_OPEN_NTCREATEX
;
1794 io
.ntcreatex
.in
.flags
= NTCREATEX_FLAGS_EXTENDED
;
1795 io
.ntcreatex
.in
.access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
1796 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_DIRECTORY
;
1797 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
| NTCREATEX_SHARE_ACCESS_WRITE
;
1798 io
.ntcreatex
.in
.create_options
= NTCREATEX_OPTIONS_DIRECTORY
;
1799 io
.ntcreatex
.in
.fname
= dname
;
1801 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1803 smbcli_rmdir(cli
->tree
, dname
);
1804 smbcli_unlink(cli
->tree
, dname
);
1806 /* test the open disposition for directories */
1807 torture_comment(tctx
, "Testing open dispositions for directories...\n");
1809 for (i
=0; i
<ARRAY_SIZE(open_funcs_dir
); i
++) {
1810 if (open_funcs_dir
[i
].dir_exists
) {
1811 status
= smbcli_mkdir(cli
->tree
, dname
);
1812 if (!NT_STATUS_IS_OK(status
)) {
1813 torture_result(tctx
, TORTURE_FAIL
,
1814 "(%s): Failed to make directory "
1815 "%s - %s\n", __location__
, dname
,
1816 smbcli_errstr(cli
->tree
));
1822 io
.ntcreatex
.in
.open_disposition
= open_funcs_dir
[i
].open_disp
;
1823 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1824 if (!NT_STATUS_EQUAL(status
, open_funcs_dir
[i
].correct_status
)) {
1825 torture_result(tctx
, TORTURE_FAIL
,
1826 "(%s) incorrect status %s should be %s "
1827 "(i=%d dir_exists=%d open_disp=%d)\n",
1828 __location__
, nt_errstr(status
),
1829 nt_errstr(open_funcs_dir
[i
].correct_status
),
1830 i
, (int)open_funcs_dir
[i
].dir_exists
,
1831 (int)open_funcs_dir
[i
].open_disp
);
1834 if (NT_STATUS_IS_OK(status
) || open_funcs_dir
[i
].dir_exists
) {
1835 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
1836 smbcli_rmdir(cli
->tree
, dname
);
1841 smbcli_deltree(cli
->tree
, BASEDIR
);
1847 * Test what happens when trying to open a file with directory parameters and
1848 * vice-versa. Also test that NTCREATEX_OPTIONS_DIRECTORY is treated as
1849 * mandatory and FILE_ATTRIBUTE_DIRECTORY is advisory for directory
1852 static bool test_ntcreatexdir(struct torture_context
*tctx
,
1853 struct smbcli_state
*cli
)
1856 const char *fname
= BASEDIR
"\\torture_ntcreatex.txt";
1857 const char *dname
= BASEDIR
"\\torture_ntcreatex_dir";
1864 uint32_t create_options
;
1865 NTSTATUS correct_status
;
1867 { NTCREATEX_DISP_SUPERSEDE
, 0, NTCREATEX_OPTIONS_DIRECTORY
,
1868 NT_STATUS_INVALID_PARAMETER
},
1869 { NTCREATEX_DISP_OPEN
, 0, NTCREATEX_OPTIONS_DIRECTORY
,
1870 NT_STATUS_OBJECT_NAME_NOT_FOUND
},
1871 { NTCREATEX_DISP_CREATE
, 0, NTCREATEX_OPTIONS_DIRECTORY
,
1873 { NTCREATEX_DISP_OPEN_IF
, 0, NTCREATEX_OPTIONS_DIRECTORY
,
1875 { NTCREATEX_DISP_OVERWRITE
, 0, NTCREATEX_OPTIONS_DIRECTORY
,
1876 NT_STATUS_INVALID_PARAMETER
},
1877 { NTCREATEX_DISP_OVERWRITE_IF
, 0, NTCREATEX_OPTIONS_DIRECTORY
,
1878 NT_STATUS_INVALID_PARAMETER
},
1879 { NTCREATEX_DISP_SUPERSEDE
, FILE_ATTRIBUTE_DIRECTORY
, 0,
1881 { NTCREATEX_DISP_OPEN
, FILE_ATTRIBUTE_DIRECTORY
, 0,
1882 NT_STATUS_OBJECT_NAME_NOT_FOUND
},
1883 { NTCREATEX_DISP_CREATE
, FILE_ATTRIBUTE_DIRECTORY
, 0,
1885 { NTCREATEX_DISP_OPEN_IF
, FILE_ATTRIBUTE_DIRECTORY
, 0,
1887 { NTCREATEX_DISP_OVERWRITE
, FILE_ATTRIBUTE_DIRECTORY
, 0,
1888 NT_STATUS_OBJECT_NAME_NOT_FOUND
},
1889 { NTCREATEX_DISP_OVERWRITE_IF
, FILE_ATTRIBUTE_DIRECTORY
, 0,
1894 torture_assert(tctx
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
1896 /* setup some base params. */
1897 io
.generic
.level
= RAW_OPEN_NTCREATEX
;
1898 io
.ntcreatex
.in
.flags
= NTCREATEX_FLAGS_EXTENDED
;
1899 io
.ntcreatex
.in
.root_fid
.fnum
= 0;
1900 io
.ntcreatex
.in
.access_mask
= SEC_RIGHTS_FILE_ALL
;
1901 io
.ntcreatex
.in
.alloc_size
= 0;
1902 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_NONE
;
1903 io
.ntcreatex
.in
.impersonation
= NTCREATEX_IMPERSONATION_ANONYMOUS
;
1904 io
.ntcreatex
.in
.security_flags
= 0;
1905 io
.ntcreatex
.in
.fname
= fname
;
1908 * Test the validity checking for create dispositions, which is done
1909 * against the requested parameters rather than what's actually on
1912 for (i
=0; i
<ARRAY_SIZE(open_funcs
); i
++) {
1913 io
.ntcreatex
.in
.open_disposition
= open_funcs
[i
].open_disp
;
1914 io
.ntcreatex
.in
.file_attr
= open_funcs
[i
].file_attr
;
1915 io
.ntcreatex
.in
.create_options
= open_funcs
[i
].create_options
;
1916 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1917 if (!NT_STATUS_EQUAL(status
, open_funcs
[i
].correct_status
)) {
1918 torture_result(tctx
, TORTURE_FAIL
,
1919 "(%s) incorrect status %s should be %s "
1920 "(i=%d open_disp=%d)\n",
1921 __location__
, nt_errstr(status
),
1922 nt_errstr(open_funcs
[i
].correct_status
),
1923 i
, (int)open_funcs
[i
].open_disp
);
1926 /* Close and delete the file. */
1927 if (NT_STATUS_IS_OK(status
)) {
1928 if (open_funcs
[i
].create_options
!= 0) {
1929 /* out attrib should be a directory. */
1930 torture_assert_int_equal(tctx
,
1931 io
.ntcreatex
.out
.attrib
,
1932 FILE_ATTRIBUTE_DIRECTORY
, "should have "
1933 "created a directory");
1935 smbcli_close(cli
->tree
,
1936 io
.ntcreatex
.out
.file
.fnum
);
1938 /* Make sure unlink fails. */
1939 status
= smbcli_unlink(cli
->tree
, fname
);
1940 torture_assert_ntstatus_equal(tctx
, status
,
1941 NT_STATUS_FILE_IS_A_DIRECTORY
,
1942 "unlink should fail for a directory");
1944 status
= smbcli_rmdir(cli
->tree
, fname
);
1945 torture_assert_ntstatus_ok(tctx
, status
,
1948 torture_assert_int_equal(tctx
,
1949 io
.ntcreatex
.out
.attrib
,
1950 FILE_ATTRIBUTE_ARCHIVE
, "should not have "
1951 "created a directory");
1953 smbcli_close(cli
->tree
,
1954 io
.ntcreatex
.out
.file
.fnum
);
1956 /* Make sure rmdir fails. */
1957 status
= smbcli_rmdir(cli
->tree
, fname
);
1958 torture_assert_ntstatus_equal(tctx
, status
,
1959 NT_STATUS_NOT_A_DIRECTORY
,
1960 "rmdir should fail for a file");
1962 status
= smbcli_unlink(cli
->tree
, fname
);
1963 torture_assert_ntstatus_ok(tctx
, status
,
1969 /* Create a file. */
1970 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
1971 io
.ntcreatex
.in
.create_options
= 0;
1972 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
1973 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1974 torture_assert_ntstatus_ok(tctx
, status
, "Failed to create file.");
1975 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
1977 /* Try and open the file with file_attr_dir and check the error. */
1978 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_DIRECTORY
;
1979 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OPEN
;
1981 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1982 torture_assert_ntstatus_ok(tctx
, status
, "FILE_ATTRIBUTE_DIRECTORY "
1983 "doesn't produce a hard failure.");
1984 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
1986 /* Try and open file with createx_option_dir and check the error. */
1987 io
.ntcreatex
.in
.file_attr
= 0;
1988 io
.ntcreatex
.in
.create_options
= NTCREATEX_OPTIONS_DIRECTORY
;
1990 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
1991 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_NOT_A_DIRECTORY
,
1992 "NTCREATEX_OPTIONS_DIRECTORY will a file from being opened.");
1993 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
1995 /* Delete the file and move onto directory testing. */
1996 smbcli_unlink(cli
->tree
, fname
);
1998 /* Now try some tests on a directory. */
1999 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
2000 io
.ntcreatex
.in
.file_attr
= 0;
2001 io
.ntcreatex
.in
.create_options
= NTCREATEX_OPTIONS_DIRECTORY
;
2002 io
.ntcreatex
.in
.fname
= dname
;
2004 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
2005 torture_assert_ntstatus_ok(tctx
, status
, "Failed to create dir.");
2007 /* out attrib should be a directory. */
2008 torture_assert_int_equal(tctx
, io
.ntcreatex
.out
.attrib
,
2009 FILE_ATTRIBUTE_DIRECTORY
, "should have created a directory");
2011 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
2013 /* Try and open it with normal attr and check the error. */
2014 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
2015 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OPEN
;
2017 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
2018 torture_assert_ntstatus_ok(tctx
, status
, "FILE_ATTRIBUTE_NORMAL "
2019 "doesn't produce a hard failure.");
2020 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
2022 /* Try and open it with file create_options and check the error. */
2023 io
.ntcreatex
.in
.file_attr
= 0;
2024 io
.ntcreatex
.in
.create_options
= NTCREATEX_OPTIONS_NON_DIRECTORY_FILE
;
2026 status
= smb_raw_open(cli
->tree
, tctx
, &io
);
2027 torture_assert_ntstatus_equal(tctx
, status
,
2028 NT_STATUS_FILE_IS_A_DIRECTORY
,
2029 "NTCREATEX_OPTIONS_NON_DIRECTORY_FILE should be returned ");
2030 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
2032 smbcli_deltree(cli
->tree
, BASEDIR
);
2037 /* basic testing of all RAW_OPEN_* calls
2039 struct torture_suite
*torture_raw_open(TALLOC_CTX
*mem_ctx
)
2041 struct torture_suite
*suite
= torture_suite_create(mem_ctx
, "open");
2043 torture_suite_add_1smb_test(suite
, "brlocked", test_ntcreatex_brlocked
);
2044 torture_suite_add_1smb_test(suite
, "open", test_open
);
2045 torture_suite_add_1smb_test(suite
, "open-multi", test_raw_open_multi
);
2046 torture_suite_add_1smb_test(suite
, "openx", test_openx
);
2047 torture_suite_add_1smb_test(suite
, "ntcreatex", test_ntcreatex
);
2048 torture_suite_add_1smb_test(suite
, "nttrans-create", test_nttrans_create
);
2049 torture_suite_add_1smb_test(suite
, "t2open", test_t2open
);
2050 torture_suite_add_1smb_test(suite
, "mknew", test_mknew
);
2051 torture_suite_add_1smb_test(suite
, "create", test_create
);
2052 torture_suite_add_1smb_test(suite
, "ctemp", test_ctemp
);
2053 torture_suite_add_1smb_test(suite
, "chained-openx", test_chained
);
2054 torture_suite_add_1smb_test(suite
, "chained-ntcreatex", test_chained_ntcreatex_readx
);
2055 torture_suite_add_1smb_test(suite
, "no-leading-slash", test_no_leading_slash
);
2056 torture_suite_add_1smb_test(suite
, "openx-over-dir", test_openx_over_dir
);
2057 torture_suite_add_1smb_test(suite
, "open-for-delete", test_open_for_delete
);
2058 torture_suite_add_1smb_test(suite
, "opendisp-dir", test_ntcreatex_opendisp_dir
);
2059 torture_suite_add_1smb_test(suite
, "ntcreatedir", test_ntcreatexdir
);