torture: use tevent_ functions names instead of the legacy event_ ones
[kai/samba.git] / source4 / torture / raw / open.c
1 /* 
2    Unix SMB/CIFS implementation.
3    RAW_OPEN_* 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 3 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "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"
28
29 /* enum for whether reads/writes are possible on a file */
30 enum rdwr_mode {RDWR_NONE, RDWR_RDONLY, RDWR_WRONLY, RDWR_RDWR};
31
32 #define BASEDIR "\\rawopen"
33
34 /*
35   check if a open file can be read/written
36 */
37 static enum rdwr_mode check_rdwr(struct smbcli_tree *tree, int fnum)
38 {
39         uint8_t c = 1;
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;
45         return RDWR_NONE;
46 }
47
48 /*
49   describe a RDWR mode as a string
50 */
51 static const char *rdwr_string(enum rdwr_mode m)
52 {
53         switch (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";
58         }
59         return "-";
60 }
61
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)); \
67                 ret = false; \
68                 goto done; \
69         }} while (0)
70
71 #define CREATE_FILE do { \
72         fnum = create_complex_file(cli, tctx, fname); \
73         if (fnum == -1) { \
74                 torture_result(tctx, TORTURE_FAIL, \
75                         "(%s) Failed to create %s - %s\n", \
76                          __location__, fname, smbcli_errstr(cli->tree)); \
77                 ret = false; \
78                 goto done; \
79         }} while (0)
80
81 #define CHECK_RDWR(fnum, correct) do { \
82         enum rdwr_mode m = check_rdwr(cli->tree, fnum); \
83         if (m != correct) { \
84                 torture_result(tctx, TORTURE_FAIL, \
85                        "(%s) Incorrect readwrite mode %s - expected %s\n", \
86                        __location__, rdwr_string(m), rdwr_string(correct)); \
87                 ret = false; \
88         }} while (0)
89
90 #define CHECK_TIME(t, field) do { \
91         time_t t1, t2; \
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); \
96         t1 = t & ~1; \
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); \
105                 ret = false; \
106         }} while (0)
107
108 #define CHECK_NTTIME(t, field) do { \
109         NTTIME t2; \
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; \
115         if (t != t2) { \
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); \
122                 ret = false; \
123         }} while (0)
124
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); \
135                 ret = false; \
136         }} while (0)
137
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)); \
143                 ret = false; \
144         }} while (0)
145
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); \
156         }} while (0)
157
158 /*
159   test RAW_OPEN_OPEN
160 */
161 static bool test_open(struct torture_context *tctx, struct smbcli_state *cli)
162 {
163         union smb_open io;
164         union smb_fileinfo finfo;
165         const char *fname = BASEDIR "\\torture_open.txt";
166         NTSTATUS status;
167         int fnum = -1, fnum2;
168         bool ret = true;
169
170         if (!torture_setup_dir(cli, BASEDIR)) {
171                 return false;
172         }
173
174         io.openold.level = RAW_OPEN_OPEN;
175         io.openold.in.fname = fname;
176         io.openold.in.open_mode = OPEN_FLAGS_FCB;
177         io.openold.in.search_attrs = 0;
178         status = smb_raw_open(cli->tree, tctx, &io);
179         CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
180         fnum = io.openold.out.file.fnum;
181
182         smbcli_unlink(cli->tree, fname);
183         CREATE_FILE;
184         smbcli_close(cli->tree, fnum);
185
186         status = smb_raw_open(cli->tree, tctx, &io);
187         CHECK_STATUS(status, NT_STATUS_OK);
188         fnum = io.openold.out.file.fnum;
189         CHECK_RDWR(fnum, RDWR_RDWR);
190
191         status = smb_raw_open(cli->tree, tctx, &io);
192         CHECK_STATUS(status, NT_STATUS_OK);
193         fnum2 = io.openold.out.file.fnum;
194         CHECK_RDWR(fnum2, RDWR_RDWR);
195         smbcli_close(cli->tree, fnum2);
196         smbcli_close(cli->tree, fnum);
197
198         /* check the read/write modes */
199         io.openold.level = RAW_OPEN_OPEN;
200         io.openold.in.fname = fname;
201         io.openold.in.search_attrs = 0;
202
203         io.openold.in.open_mode = OPEN_FLAGS_OPEN_READ;
204         status = smb_raw_open(cli->tree, tctx, &io);
205         CHECK_STATUS(status, NT_STATUS_OK);
206         fnum = io.openold.out.file.fnum;
207         CHECK_RDWR(fnum, RDWR_RDONLY);
208         smbcli_close(cli->tree, fnum);
209
210         io.openold.in.open_mode = OPEN_FLAGS_OPEN_WRITE;
211         status = smb_raw_open(cli->tree, tctx, &io);
212         CHECK_STATUS(status, NT_STATUS_OK);
213         fnum = io.openold.out.file.fnum;
214         CHECK_RDWR(fnum, RDWR_WRONLY);
215         smbcli_close(cli->tree, fnum);
216
217         io.openold.in.open_mode = OPEN_FLAGS_OPEN_RDWR;
218         status = smb_raw_open(cli->tree, tctx, &io);
219         CHECK_STATUS(status, NT_STATUS_OK);
220         fnum = io.openold.out.file.fnum;
221         CHECK_RDWR(fnum, RDWR_RDWR);
222         smbcli_close(cli->tree, fnum);
223
224         /* check the share modes roughly - not a complete matrix */
225         io.openold.in.open_mode = OPEN_FLAGS_OPEN_RDWR | OPEN_FLAGS_DENY_WRITE;
226         status = smb_raw_open(cli->tree, tctx, &io);
227         CHECK_STATUS(status, NT_STATUS_OK);
228         fnum = io.openold.out.file.fnum;
229         CHECK_RDWR(fnum, RDWR_RDWR);
230         
231         if (io.openold.in.open_mode != io.openold.out.rmode) {
232                 torture_warning(tctx, "(%s) rmode should equal open_mode - 0x%x 0x%x\n",
233                        __location__, io.openold.out.rmode, io.openold.in.open_mode);
234         }
235
236         io.openold.in.open_mode = OPEN_FLAGS_OPEN_RDWR | OPEN_FLAGS_DENY_NONE;
237         status = smb_raw_open(cli->tree, tctx, &io);
238         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
239
240         io.openold.in.open_mode = OPEN_FLAGS_OPEN_READ | OPEN_FLAGS_DENY_NONE;
241         status = smb_raw_open(cli->tree, tctx, &io);
242         CHECK_STATUS(status, NT_STATUS_OK);
243         fnum2 = io.openold.out.file.fnum;
244         CHECK_RDWR(fnum2, RDWR_RDONLY);
245         smbcli_close(cli->tree, fnum);
246         smbcli_close(cli->tree, fnum2);
247
248
249         /* check the returned write time */
250         io.openold.level = RAW_OPEN_OPEN;
251         io.openold.in.fname = fname;
252         io.openold.in.search_attrs = 0;
253         io.openold.in.open_mode = OPEN_FLAGS_OPEN_READ;
254         status = smb_raw_open(cli->tree, tctx, &io);
255         CHECK_STATUS(status, NT_STATUS_OK);
256         fnum = io.openold.out.file.fnum;
257
258         /* check other reply fields */
259         CHECK_TIME(io.openold.out.write_time, write_time);
260         CHECK_ALL_INFO(io.openold.out.size, size);
261         CHECK_ALL_INFO(io.openold.out.attrib, attrib & ~FILE_ATTRIBUTE_NONINDEXED);
262
263 done:
264         smbcli_close(cli->tree, fnum);
265         smbcli_deltree(cli->tree, BASEDIR);
266
267         return ret;
268 }
269
270
271 /*
272   test RAW_OPEN_OPENX
273 */
274 static bool test_openx(struct torture_context *tctx, struct smbcli_state *cli)
275 {
276         union smb_open io;
277         union smb_fileinfo finfo;
278         const char *fname = BASEDIR "\\torture_openx.txt";
279         const char *fname_exe = BASEDIR "\\torture_openx.exe";
280         NTSTATUS status;
281         int fnum = -1, fnum2;
282         bool ret = true;
283         int i;
284         struct timeval tv;
285         struct {
286                 uint16_t open_func;
287                 bool with_file;
288                 NTSTATUS correct_status;
289         } open_funcs[] = {
290                 { OPENX_OPEN_FUNC_OPEN,                           true,  NT_STATUS_OK },
291                 { OPENX_OPEN_FUNC_OPEN,                           false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
292                 { OPENX_OPEN_FUNC_OPEN  | OPENX_OPEN_FUNC_CREATE, true,  NT_STATUS_OK },
293                 { OPENX_OPEN_FUNC_OPEN  | OPENX_OPEN_FUNC_CREATE, false, NT_STATUS_OK },
294                 { OPENX_OPEN_FUNC_FAIL,                           true,  NT_STATUS_DOS(ERRDOS, ERRbadaccess) },
295                 { OPENX_OPEN_FUNC_FAIL,                           false, NT_STATUS_DOS(ERRDOS, ERRbadaccess) },
296                 { OPENX_OPEN_FUNC_FAIL  | OPENX_OPEN_FUNC_CREATE, true,  NT_STATUS_OBJECT_NAME_COLLISION },
297                 { OPENX_OPEN_FUNC_FAIL  | OPENX_OPEN_FUNC_CREATE, false, NT_STATUS_OK },
298                 { OPENX_OPEN_FUNC_TRUNC,                          true,  NT_STATUS_OK },
299                 { OPENX_OPEN_FUNC_TRUNC,                          false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
300                 { OPENX_OPEN_FUNC_TRUNC | OPENX_OPEN_FUNC_CREATE, true,  NT_STATUS_OK },
301                 { OPENX_OPEN_FUNC_TRUNC | OPENX_OPEN_FUNC_CREATE, false, NT_STATUS_OK },
302         };
303
304         if (!torture_setup_dir(cli, BASEDIR)) {
305                 return false;
306         }
307
308         io.openx.level = RAW_OPEN_OPENX;
309         io.openx.in.fname = fname;
310         io.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
311         io.openx.in.open_mode = OPENX_MODE_ACCESS_RDWR;
312         io.openx.in.search_attrs = 0;
313         io.openx.in.file_attrs = 0;
314         io.openx.in.write_time = 0;
315         io.openx.in.size = 1024*1024;
316         io.openx.in.timeout = 0;
317
318         /* check all combinations of open_func */
319         for (i=0; i<ARRAY_SIZE(open_funcs); i++) {
320                 if (open_funcs[i].with_file) {
321                         fnum = create_complex_file(cli, tctx, fname);
322                         if (fnum == -1) {
323                                 torture_result(tctx, TORTURE_FAIL,
324                                         "Failed to create file %s - %s\n",
325                                         fname, smbcli_errstr(cli->tree));
326                                 ret = false;
327                                 goto done;
328                         }
329                         smbcli_close(cli->tree, fnum);
330                 }
331                 io.openx.in.open_func = open_funcs[i].open_func;
332                 status = smb_raw_open(cli->tree, tctx, &io);
333                 if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
334                         torture_result(tctx, TORTURE_FAIL,
335                                 "(%s) incorrect status %s should be %s "
336                                 "(i=%d with_file=%d open_func=0x%x)\n",
337                                 __location__, nt_errstr(status),
338                                 nt_errstr(open_funcs[i].correct_status),
339                                 i, (int)open_funcs[i].with_file,
340                                 open_funcs[i].open_func);
341                         ret = false;
342                 }
343                 if (NT_STATUS_IS_OK(status)) {
344                         smbcli_close(cli->tree, io.openx.out.file.fnum);
345                 }
346                 if (open_funcs[i].with_file) {
347                         smbcli_unlink(cli->tree, fname);
348                 }
349         }
350
351         smbcli_unlink(cli->tree, fname);
352
353         /* check the basic return fields */
354         io.openx.in.open_func = OPENX_OPEN_FUNC_OPEN | OPENX_OPEN_FUNC_CREATE;
355         status = smb_raw_open(cli->tree, tctx, &io);
356         CHECK_STATUS(status, NT_STATUS_OK);
357         fnum = io.openx.out.file.fnum;
358
359         CHECK_ALL_INFO(io.openx.out.size, size);
360         CHECK_TIME(io.openx.out.write_time, write_time);
361         CHECK_ALL_INFO(io.openx.out.attrib, attrib & ~FILE_ATTRIBUTE_NONINDEXED);
362         CHECK_VAL(io.openx.out.access, OPENX_MODE_ACCESS_RDWR);
363         CHECK_VAL(io.openx.out.ftype, 0);
364         CHECK_VAL(io.openx.out.devstate, 0);
365         CHECK_VAL(io.openx.out.action, OPENX_ACTION_CREATED);
366         CHECK_VAL(io.openx.out.size, 1024*1024);
367         CHECK_ALL_INFO(io.openx.in.size, size);
368         smbcli_close(cli->tree, fnum);
369         smbcli_unlink(cli->tree, fname);
370
371         /* check the fields when the file already existed */
372         fnum2 = create_complex_file(cli, tctx, fname);
373         if (fnum2 == -1) {
374                 ret = false;
375                 goto done;
376         }
377         smbcli_close(cli->tree, fnum2);
378
379         io.openx.in.open_func = OPENX_OPEN_FUNC_OPEN;
380         status = smb_raw_open(cli->tree, tctx, &io);
381         CHECK_STATUS(status, NT_STATUS_OK);
382         fnum = io.openx.out.file.fnum;
383
384         CHECK_ALL_INFO(io.openx.out.size, size);
385         CHECK_TIME(io.openx.out.write_time, write_time);
386         CHECK_VAL(io.openx.out.action, OPENX_ACTION_EXISTED);
387         CHECK_VAL(io.openx.out.unknown, 0);
388         CHECK_ALL_INFO(io.openx.out.attrib, attrib & ~FILE_ATTRIBUTE_NONINDEXED);
389         smbcli_close(cli->tree, fnum);
390
391         /* now check the search attrib for hidden files - win2003 ignores this? */
392         SET_ATTRIB(FILE_ATTRIBUTE_HIDDEN);
393         CHECK_ALL_INFO(FILE_ATTRIBUTE_HIDDEN, attrib);
394
395         io.openx.in.search_attrs = FILE_ATTRIBUTE_HIDDEN;
396         status = smb_raw_open(cli->tree, tctx, &io);
397         CHECK_STATUS(status, NT_STATUS_OK);
398         smbcli_close(cli->tree, io.openx.out.file.fnum);
399
400         io.openx.in.search_attrs = 0;
401         status = smb_raw_open(cli->tree, tctx, &io);
402         CHECK_STATUS(status, NT_STATUS_OK);
403         smbcli_close(cli->tree, io.openx.out.file.fnum);
404
405         SET_ATTRIB(FILE_ATTRIBUTE_NORMAL);
406         smbcli_unlink(cli->tree, fname);
407
408         /* and check attrib on create */
409         io.openx.in.open_func = OPENX_OPEN_FUNC_FAIL | OPENX_OPEN_FUNC_CREATE;
410         io.openx.in.search_attrs = 0;
411         io.openx.in.file_attrs = FILE_ATTRIBUTE_SYSTEM;
412         status = smb_raw_open(cli->tree, tctx, &io);
413         CHECK_STATUS(status, NT_STATUS_OK);
414         if (torture_setting_bool(tctx, "samba3", false)) {
415                 CHECK_ALL_INFO(FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE, 
416                                attrib & ~(FILE_ATTRIBUTE_NONINDEXED|
417                                           FILE_ATTRIBUTE_SPARSE));
418         }
419         else {
420                 CHECK_ALL_INFO(FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE, 
421                                attrib & ~(FILE_ATTRIBUTE_NONINDEXED));
422         }
423         smbcli_close(cli->tree, io.openx.out.file.fnum);
424         smbcli_unlink(cli->tree, fname);
425
426         /* check timeout on create - win2003 ignores the timeout! */
427         io.openx.in.open_func = OPENX_OPEN_FUNC_OPEN | OPENX_OPEN_FUNC_CREATE;
428         io.openx.in.file_attrs = 0;
429         io.openx.in.open_mode = OPENX_MODE_ACCESS_RDWR | OPENX_MODE_DENY_ALL;
430         status = smb_raw_open(cli->tree, tctx, &io);
431         CHECK_STATUS(status, NT_STATUS_OK);
432         fnum = io.openx.out.file.fnum;
433
434         io.openx.in.timeout = 20000;
435         tv = timeval_current();
436         io.openx.in.open_mode = OPENX_MODE_ACCESS_RDWR | OPENX_MODE_DENY_NONE;
437         status = smb_raw_open(cli->tree, tctx, &io);
438         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
439         if (timeval_elapsed(&tv) > 3.0) {
440                 torture_result(tctx, TORTURE_FAIL,
441                         "(%s) Incorrect timing in openx with timeout "
442                         "- waited %.2f seconds\n",
443                         __location__, timeval_elapsed(&tv));
444                 ret = false;
445         }
446         smbcli_close(cli->tree, fnum);
447         smbcli_unlink(cli->tree, fname);
448
449         /* now this is a really weird one - open for execute implies create?! */
450         io.openx.in.fname = fname;
451         io.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
452         io.openx.in.open_mode = OPENX_MODE_ACCESS_EXEC | OPENX_MODE_DENY_NONE;
453         io.openx.in.search_attrs = 0;
454         io.openx.in.open_func = OPENX_OPEN_FUNC_FAIL;
455         io.openx.in.file_attrs = 0;
456         io.openx.in.write_time = 0;
457         io.openx.in.size = 0;
458         io.openx.in.timeout = 0;
459         status = smb_raw_open(cli->tree, tctx, &io);
460         CHECK_STATUS(status, NT_STATUS_OK);
461         smbcli_close(cli->tree, io.openx.out.file.fnum);
462
463         /* check the extended return flag */
464         io.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO | OPENX_FLAGS_EXTENDED_RETURN;
465         io.openx.in.open_func = OPENX_OPEN_FUNC_OPEN;
466         status = smb_raw_open(cli->tree, tctx, &io);
467         CHECK_STATUS(status, NT_STATUS_OK);
468         CHECK_VAL(io.openx.out.access_mask, SEC_STD_ALL);
469         smbcli_close(cli->tree, io.openx.out.file.fnum);
470
471         io.openx.in.fname = "\\A.+,;=[].B";
472         status = smb_raw_open(cli->tree, tctx, &io);
473         CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
474
475         /* Check the mapping for open exec. */
476
477         /* First create an .exe file. */
478         smbcli_unlink(cli->tree, fname_exe);
479         fnum = create_complex_file(cli, tctx, fname_exe);
480         smbcli_close(cli->tree, fnum);
481
482         io.openx.level = RAW_OPEN_OPENX;
483         io.openx.in.fname = fname_exe;
484         io.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
485         io.openx.in.open_mode = OPENX_MODE_ACCESS_EXEC | OPENX_MODE_DENY_NONE;
486         io.openx.in.search_attrs = 0;
487         io.openx.in.file_attrs = 0;
488         io.openx.in.write_time = 0;
489         io.openx.in.size = 0;
490         io.openx.in.timeout = 0;
491         status = smb_raw_open(cli->tree, tctx, &io);
492         CHECK_STATUS(status, NT_STATUS_OK);
493
494         /* Can we read and write ? */
495         CHECK_RDWR(io.openx.out.file.fnum, RDWR_RDONLY);
496         smbcli_close(cli->tree, io.openx.out.file.fnum);
497         smbcli_unlink(cli->tree, fname);
498
499 done:
500         smbcli_close(cli->tree, fnum);
501         smbcli_deltree(cli->tree, BASEDIR);
502
503         return ret;
504 }
505
506
507 /*
508   test RAW_OPEN_T2OPEN
509
510   many thanks to kukks for a sniff showing how this works with os2->w2k
511 */
512 static bool test_t2open(struct torture_context *tctx, struct smbcli_state *cli)
513 {
514         union smb_open io;
515         union smb_fileinfo finfo;
516         const char *fname1 = BASEDIR "\\torture_t2open_yes.txt";
517         const char *fname2 = BASEDIR "\\torture_t2open_no.txt";
518         const char *fname = BASEDIR "\\torture_t2open_3.txt";
519         NTSTATUS status;
520         int fnum;
521         bool ret = true;
522         int i;
523         struct {
524                 uint16_t open_func;
525                 bool with_file;
526                 NTSTATUS correct_status;
527         } open_funcs[] = {
528                 { OPENX_OPEN_FUNC_OPEN,                           true,  NT_STATUS_OK },
529                 { OPENX_OPEN_FUNC_OPEN,                           false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
530                 { OPENX_OPEN_FUNC_OPEN  | OPENX_OPEN_FUNC_CREATE, true,  NT_STATUS_OK },
531                 { OPENX_OPEN_FUNC_OPEN  | OPENX_OPEN_FUNC_CREATE, false, NT_STATUS_OK },
532                 { OPENX_OPEN_FUNC_FAIL,                           true,  NT_STATUS_OBJECT_NAME_COLLISION },
533                 { OPENX_OPEN_FUNC_FAIL,                           false, NT_STATUS_OBJECT_NAME_COLLISION },
534                 { OPENX_OPEN_FUNC_FAIL  | OPENX_OPEN_FUNC_CREATE, true,  NT_STATUS_OBJECT_NAME_COLLISION },
535                 { OPENX_OPEN_FUNC_FAIL  | OPENX_OPEN_FUNC_CREATE, false, NT_STATUS_OBJECT_NAME_COLLISION },
536                 { OPENX_OPEN_FUNC_TRUNC,                          true,  NT_STATUS_OK },
537                 { OPENX_OPEN_FUNC_TRUNC,                          false, NT_STATUS_OK },
538                 { OPENX_OPEN_FUNC_TRUNC | OPENX_OPEN_FUNC_CREATE, true,  NT_STATUS_OK },
539                 { OPENX_OPEN_FUNC_TRUNC | OPENX_OPEN_FUNC_CREATE, false, NT_STATUS_OK },
540         };
541
542         if (!torture_setup_dir(cli, BASEDIR)) {
543                 return false;
544         }
545
546         fnum = create_complex_file(cli, tctx, fname1);
547         if (fnum == -1) {
548                 torture_result(tctx, TORTURE_FAIL,
549                         "(%s): Failed to create file %s - %s\n",
550                         __location__, fname1, smbcli_errstr(cli->tree));
551                 ret = false;
552                 goto done;
553         }
554         smbcli_close(cli->tree, fnum);
555
556         io.t2open.level = RAW_OPEN_T2OPEN;
557         io.t2open.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
558         io.t2open.in.open_mode = OPENX_MODE_DENY_NONE | OPENX_MODE_ACCESS_RDWR;
559         io.t2open.in.open_func = OPENX_OPEN_FUNC_OPEN | OPENX_OPEN_FUNC_CREATE;
560         io.t2open.in.search_attrs = 0;
561         io.t2open.in.file_attrs = 0;
562         io.t2open.in.write_time = 0;
563         io.t2open.in.size = 0;
564         io.t2open.in.timeout = 0;
565
566         io.t2open.in.num_eas = 3;
567         io.t2open.in.eas = talloc_array(tctx, struct ea_struct, io.t2open.in.num_eas);
568         io.t2open.in.eas[0].flags = 0;
569         io.t2open.in.eas[0].name.s = ".CLASSINFO";
570         io.t2open.in.eas[0].value = data_blob_talloc(tctx, "first value", 11);
571         io.t2open.in.eas[1].flags = 0;
572         io.t2open.in.eas[1].name.s = "EA TWO";
573         io.t2open.in.eas[1].value = data_blob_talloc(tctx, "foo", 3);
574         io.t2open.in.eas[2].flags = 0;
575         io.t2open.in.eas[2].name.s = "X THIRD";
576         io.t2open.in.eas[2].value = data_blob_talloc(tctx, "xy", 2);
577
578         /* check all combinations of open_func */
579         for (i=0; i<ARRAY_SIZE(open_funcs); i++) {
580         again:
581                 if (open_funcs[i].with_file) {
582                         io.t2open.in.fname = fname1;
583                 } else {
584                         io.t2open.in.fname = fname2;
585                 }
586                 io.t2open.in.open_func = open_funcs[i].open_func;
587                 status = smb_raw_open(cli->tree, tctx, &io);
588                 if ((io.t2open.in.num_eas != 0)
589                     && NT_STATUS_EQUAL(status, NT_STATUS_EAS_NOT_SUPPORTED)
590                     && torture_setting_bool(tctx, "samba3", false)) {
591                         torture_warning(tctx, "(%s) EAs not supported, not "
592                                 "treating as fatal in Samba3 test\n",
593                                 __location__);
594                         io.t2open.in.num_eas = 0;
595                         goto again;
596                 }
597
598                 if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
599                         torture_result(tctx, TORTURE_FAIL,
600                                 "(%s) incorrect status %s should be %s "
601                                 "(i=%d with_file=%d open_func=0x%x)\n",
602                                  __location__, nt_errstr(status),
603                                 nt_errstr(open_funcs[i].correct_status),
604                                 i, (int)open_funcs[i].with_file,
605                                 open_funcs[i].open_func);
606                         ret = false;
607                 }
608                 if (NT_STATUS_IS_OK(status)) {
609                         smbcli_close(cli->tree, io.t2open.out.file.fnum);
610                 }
611         }
612
613         smbcli_unlink(cli->tree, fname1);
614         smbcli_unlink(cli->tree, fname2);
615
616         /* check the basic return fields */
617         io.t2open.in.open_func = OPENX_OPEN_FUNC_OPEN | OPENX_OPEN_FUNC_CREATE;
618         io.t2open.in.write_time = 0;
619         io.t2open.in.fname = fname;
620         status = smb_raw_open(cli->tree, tctx, &io);
621         CHECK_STATUS(status, NT_STATUS_OK);
622         fnum = io.t2open.out.file.fnum;
623
624         CHECK_ALL_INFO(io.t2open.out.size, size);
625 #if 0
626         /* windows appears to leak uninitialised memory here */
627         CHECK_VAL(io.t2open.out.write_time, 0);
628 #endif
629         CHECK_ALL_INFO(io.t2open.out.attrib, attrib & ~FILE_ATTRIBUTE_NONINDEXED);
630         CHECK_VAL(io.t2open.out.access, OPENX_MODE_DENY_NONE | OPENX_MODE_ACCESS_RDWR);
631         CHECK_VAL(io.t2open.out.ftype, 0);
632         CHECK_VAL(io.t2open.out.devstate, 0);
633         CHECK_VAL(io.t2open.out.action, OPENX_ACTION_CREATED);
634         smbcli_close(cli->tree, fnum);
635
636         status = torture_check_ea(cli, fname, ".CLASSINFO", "first value");
637         CHECK_STATUS(status, io.t2open.in.num_eas
638                      ? NT_STATUS_OK : NT_STATUS_EAS_NOT_SUPPORTED);
639         status = torture_check_ea(cli, fname, "EA TWO", "foo");
640         CHECK_STATUS(status, io.t2open.in.num_eas
641                      ? NT_STATUS_OK : NT_STATUS_EAS_NOT_SUPPORTED);
642         status = torture_check_ea(cli, fname, "X THIRD", "xy");
643         CHECK_STATUS(status, io.t2open.in.num_eas
644                      ? NT_STATUS_OK : NT_STATUS_EAS_NOT_SUPPORTED);
645
646         /* now check the search attrib for hidden files - win2003 ignores this? */
647         SET_ATTRIB(FILE_ATTRIBUTE_HIDDEN);
648         CHECK_ALL_INFO(FILE_ATTRIBUTE_HIDDEN, attrib);
649
650         status = smb_raw_open(cli->tree, tctx, &io);
651         CHECK_STATUS(status, NT_STATUS_OK);
652         smbcli_close(cli->tree, io.t2open.out.file.fnum);
653
654         status = smb_raw_open(cli->tree, tctx, &io);
655         CHECK_STATUS(status, NT_STATUS_OK);
656         smbcli_close(cli->tree, io.t2open.out.file.fnum);
657
658         SET_ATTRIB(FILE_ATTRIBUTE_NORMAL);
659         smbcli_unlink(cli->tree, fname);
660
661         /* and check attrib on create */
662         io.t2open.in.open_func = OPENX_OPEN_FUNC_FAIL | OPENX_OPEN_FUNC_CREATE;
663         io.t2open.in.file_attrs = FILE_ATTRIBUTE_SYSTEM;
664         status = smb_raw_open(cli->tree, tctx, &io);
665         CHECK_STATUS(status, NT_STATUS_OK);
666
667         /* check timeout on create - win2003 ignores the timeout! */
668         io.t2open.in.open_func = OPENX_OPEN_FUNC_OPEN | OPENX_OPEN_FUNC_CREATE;
669         io.t2open.in.file_attrs = 0;
670         io.t2open.in.timeout = 20000;
671         io.t2open.in.open_mode = OPENX_MODE_ACCESS_RDWR | OPENX_MODE_DENY_ALL;
672         status = smb_raw_open(cli->tree, tctx, &io);
673         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
674
675 done:
676         smbcli_close(cli->tree, fnum);
677         smbcli_deltree(cli->tree, BASEDIR);
678
679         return ret;
680 }
681         
682
683 /*
684   test RAW_OPEN_NTCREATEX
685 */
686 static bool test_ntcreatex(struct torture_context *tctx, struct smbcli_state *cli)
687 {
688         union smb_open io;
689         union smb_fileinfo finfo;
690         const char *fname = BASEDIR "\\torture_ntcreatex.txt";
691         const char *dname = BASEDIR "\\torture_ntcreatex.dir";
692         NTSTATUS status;
693         int fnum = -1;
694         bool ret = true;
695         int i;
696         struct {
697                 uint32_t open_disp;
698                 bool with_file;
699                 NTSTATUS correct_status;
700         } open_funcs[] = {
701                 { NTCREATEX_DISP_SUPERSEDE,     true,  NT_STATUS_OK },
702                 { NTCREATEX_DISP_SUPERSEDE,     false, NT_STATUS_OK },
703                 { NTCREATEX_DISP_OPEN,          true,  NT_STATUS_OK },
704                 { NTCREATEX_DISP_OPEN,          false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
705                 { NTCREATEX_DISP_CREATE,        true,  NT_STATUS_OBJECT_NAME_COLLISION },
706                 { NTCREATEX_DISP_CREATE,        false, NT_STATUS_OK },
707                 { NTCREATEX_DISP_OPEN_IF,       true,  NT_STATUS_OK },
708                 { NTCREATEX_DISP_OPEN_IF,       false, NT_STATUS_OK },
709                 { NTCREATEX_DISP_OVERWRITE,     true,  NT_STATUS_OK },
710                 { NTCREATEX_DISP_OVERWRITE,     false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
711                 { NTCREATEX_DISP_OVERWRITE_IF,  true,  NT_STATUS_OK },
712                 { NTCREATEX_DISP_OVERWRITE_IF,  false, NT_STATUS_OK },
713                 { 6,                            true,  NT_STATUS_INVALID_PARAMETER },
714                 { 6,                            false, NT_STATUS_INVALID_PARAMETER },
715         };
716
717         if (!torture_setup_dir(cli, BASEDIR)) {
718                 return false;
719         }
720
721         /* reasonable default parameters */
722         io.generic.level = RAW_OPEN_NTCREATEX;
723         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
724         io.ntcreatex.in.root_fid.fnum = 0;
725         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
726         io.ntcreatex.in.alloc_size = 1024*1024;
727         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
728         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
729         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
730         io.ntcreatex.in.create_options = 0;
731         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
732         io.ntcreatex.in.security_flags = 0;
733         io.ntcreatex.in.fname = fname;
734
735         /* test the open disposition */
736         for (i=0; i<ARRAY_SIZE(open_funcs); i++) {
737                 if (open_funcs[i].with_file) {
738                         fnum = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR|O_TRUNC, DENY_NONE);
739                         if (fnum == -1) {
740                                 torture_result(tctx, TORTURE_FAIL,
741                                         "Failed to create file %s - %s\n",
742                                         fname, smbcli_errstr(cli->tree));
743                                 ret = false;
744                                 goto done;
745                         }
746                         smbcli_close(cli->tree, fnum);
747                 }
748                 io.ntcreatex.in.open_disposition = open_funcs[i].open_disp;
749                 status = smb_raw_open(cli->tree, tctx, &io);
750                 if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
751                         torture_result(tctx, TORTURE_FAIL,
752                                 "(%s) incorrect status %s should be %s "
753                                 "(i=%d with_file=%d open_disp=%d)\n",
754                                 __location__, nt_errstr(status),
755                                 nt_errstr(open_funcs[i].correct_status),
756                                 i, (int)open_funcs[i].with_file,
757                                 (int)open_funcs[i].open_disp);
758                         ret = false;
759                 }
760                 if (NT_STATUS_IS_OK(status) || open_funcs[i].with_file) {
761                         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
762                         smbcli_unlink(cli->tree, fname);
763                 }
764         }
765
766         /* basic field testing */
767         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
768
769         status = smb_raw_open(cli->tree, tctx, &io);
770         CHECK_STATUS(status, NT_STATUS_OK);
771         fnum = io.ntcreatex.out.file.fnum;
772
773         CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
774         CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_CREATED);
775         CHECK_NTTIME(io.ntcreatex.out.create_time, create_time);
776         CHECK_NTTIME(io.ntcreatex.out.access_time, access_time);
777         CHECK_NTTIME(io.ntcreatex.out.write_time, write_time);
778         CHECK_NTTIME(io.ntcreatex.out.change_time, change_time);
779         CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
780         CHECK_ALL_INFO(io.ntcreatex.out.alloc_size, alloc_size);
781         CHECK_ALL_INFO(io.ntcreatex.out.size, size);
782         CHECK_ALL_INFO(io.ntcreatex.out.is_directory, directory);
783         CHECK_VAL(io.ntcreatex.out.file_type, FILE_TYPE_DISK);
784
785         /* check fields when the file already existed */
786         smbcli_close(cli->tree, fnum);
787         smbcli_unlink(cli->tree, fname);
788         fnum = create_complex_file(cli, tctx, fname);
789         if (fnum == -1) {
790                 ret = false;
791                 goto done;
792         }
793         smbcli_close(cli->tree, fnum);
794
795         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
796         status = smb_raw_open(cli->tree, tctx, &io);
797         CHECK_STATUS(status, NT_STATUS_OK);
798         fnum = io.ntcreatex.out.file.fnum;
799
800         CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
801         CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_EXISTED);
802         CHECK_NTTIME(io.ntcreatex.out.create_time, create_time);
803         CHECK_NTTIME(io.ntcreatex.out.access_time, access_time);
804         CHECK_NTTIME(io.ntcreatex.out.write_time, write_time);
805         CHECK_NTTIME(io.ntcreatex.out.change_time, change_time);
806         CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
807         CHECK_ALL_INFO(io.ntcreatex.out.alloc_size, alloc_size);
808         CHECK_ALL_INFO(io.ntcreatex.out.size, size);
809         CHECK_ALL_INFO(io.ntcreatex.out.is_directory, directory);
810         CHECK_VAL(io.ntcreatex.out.file_type, FILE_TYPE_DISK);
811         smbcli_close(cli->tree, fnum);
812         smbcli_unlink(cli->tree, fname);
813
814
815         /* create a directory */
816         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
817         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
818         io.ntcreatex.in.alloc_size = 0;
819         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
820         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
821         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
822         io.ntcreatex.in.create_options = 0;
823         io.ntcreatex.in.fname = dname;
824         fname = dname;
825
826         smbcli_rmdir(cli->tree, fname);
827         smbcli_unlink(cli->tree, fname);
828
829         io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
830         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
831         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
832         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
833         status = smb_raw_open(cli->tree, tctx, &io);
834         CHECK_STATUS(status, NT_STATUS_OK);
835         fnum = io.ntcreatex.out.file.fnum;
836
837         CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
838         CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_CREATED);
839         CHECK_NTTIME(io.ntcreatex.out.create_time, create_time);
840         CHECK_NTTIME(io.ntcreatex.out.access_time, access_time);
841         CHECK_NTTIME(io.ntcreatex.out.write_time, write_time);
842         CHECK_NTTIME(io.ntcreatex.out.change_time, change_time);
843         CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
844         CHECK_VAL(io.ntcreatex.out.attrib & ~FILE_ATTRIBUTE_NONINDEXED, 
845                   FILE_ATTRIBUTE_DIRECTORY);
846         CHECK_ALL_INFO(io.ntcreatex.out.alloc_size, alloc_size);
847         CHECK_ALL_INFO(io.ntcreatex.out.size, size);
848         CHECK_ALL_INFO(io.ntcreatex.out.is_directory, directory);
849         CHECK_VAL(io.ntcreatex.out.is_directory, 1);
850         CHECK_VAL(io.ntcreatex.out.size, 0);
851         CHECK_VAL(io.ntcreatex.out.alloc_size, 0);
852         CHECK_VAL(io.ntcreatex.out.file_type, FILE_TYPE_DISK);
853         smbcli_unlink(cli->tree, fname);
854         
855
856 done:
857         smbcli_close(cli->tree, fnum);
858         smbcli_deltree(cli->tree, BASEDIR);
859
860         return ret;
861 }
862
863
864 /*
865   test RAW_OPEN_NTTRANS_CREATE
866 */
867 static bool test_nttrans_create(struct torture_context *tctx, struct smbcli_state *cli)
868 {
869         union smb_open io;
870         union smb_fileinfo finfo;
871         const char *fname = BASEDIR "\\torture_ntcreatex.txt";
872         const char *dname = BASEDIR "\\torture_ntcreatex.dir";
873         NTSTATUS status;
874         int fnum = -1;
875         bool ret = true;
876         int i;
877         uint32_t ok_mask, not_supported_mask, invalid_parameter_mask;
878         uint32_t not_a_directory_mask, unexpected_mask;
879         struct {
880                 uint32_t open_disp;
881                 bool with_file;
882                 NTSTATUS correct_status;
883         } open_funcs[] = {
884                 { NTCREATEX_DISP_SUPERSEDE,     true,  NT_STATUS_OK },
885                 { NTCREATEX_DISP_SUPERSEDE,     false, NT_STATUS_OK },
886                 { NTCREATEX_DISP_OPEN,          true,  NT_STATUS_OK },
887                 { NTCREATEX_DISP_OPEN,          false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
888                 { NTCREATEX_DISP_CREATE,        true,  NT_STATUS_OBJECT_NAME_COLLISION },
889                 { NTCREATEX_DISP_CREATE,        false, NT_STATUS_OK },
890                 { NTCREATEX_DISP_OPEN_IF,       true,  NT_STATUS_OK },
891                 { NTCREATEX_DISP_OPEN_IF,       false, NT_STATUS_OK },
892                 { NTCREATEX_DISP_OVERWRITE,     true,  NT_STATUS_OK },
893                 { NTCREATEX_DISP_OVERWRITE,     false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
894                 { NTCREATEX_DISP_OVERWRITE_IF,  true,  NT_STATUS_OK },
895                 { NTCREATEX_DISP_OVERWRITE_IF,  false, NT_STATUS_OK },
896                 { 6,                            true,  NT_STATUS_INVALID_PARAMETER },
897                 { 6,                            false, NT_STATUS_INVALID_PARAMETER },
898         };
899
900         if (!torture_setup_dir(cli, BASEDIR)) {
901                 return false;
902         }
903
904         /* reasonable default parameters */
905         io.generic.level = RAW_OPEN_NTTRANS_CREATE;
906         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
907         io.ntcreatex.in.root_fid.fnum = 0;
908         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
909         io.ntcreatex.in.alloc_size = 1024*1024;
910         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
911         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
912         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
913         io.ntcreatex.in.create_options = 0;
914         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
915         io.ntcreatex.in.security_flags = 0;
916         io.ntcreatex.in.fname = fname;
917         io.ntcreatex.in.sec_desc = NULL;
918         io.ntcreatex.in.ea_list = NULL;
919
920         /* test the open disposition */
921         for (i=0; i<ARRAY_SIZE(open_funcs); i++) {
922                 if (open_funcs[i].with_file) {
923                         fnum = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR|O_TRUNC, DENY_NONE);
924                         if (fnum == -1) {
925                                 torture_result(tctx, TORTURE_FAIL,
926                                         "Failed to create file %s - %s\n",
927                                         fname, smbcli_errstr(cli->tree));
928                                 ret = false;
929                                 goto done;
930                         }
931                         smbcli_close(cli->tree, fnum);
932                 }
933                 io.ntcreatex.in.open_disposition = open_funcs[i].open_disp;
934                 status = smb_raw_open(cli->tree, tctx, &io);
935                 if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
936                         torture_result(tctx, TORTURE_FAIL,
937                                 "(%s) incorrect status %s should be %s "
938                                 "(i=%d with_file=%d open_disp=%d)\n",
939                                 __location__, nt_errstr(status),
940                                 nt_errstr(open_funcs[i].correct_status),
941                                 i, (int)open_funcs[i].with_file,
942                                 (int)open_funcs[i].open_disp);
943                         ret = false;
944                 }
945                 if (NT_STATUS_IS_OK(status) || open_funcs[i].with_file) {
946                         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
947                         smbcli_unlink(cli->tree, fname);
948                 }
949         }
950
951         /* basic field testing */
952         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
953
954         status = smb_raw_open(cli->tree, tctx, &io);
955         CHECK_STATUS(status, NT_STATUS_OK);
956         fnum = io.ntcreatex.out.file.fnum;
957
958         CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
959         CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_CREATED);
960         CHECK_NTTIME(io.ntcreatex.out.create_time, create_time);
961         CHECK_NTTIME(io.ntcreatex.out.access_time, access_time);
962         CHECK_NTTIME(io.ntcreatex.out.write_time, write_time);
963         CHECK_NTTIME(io.ntcreatex.out.change_time, change_time);
964         CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
965         CHECK_ALL_INFO(io.ntcreatex.out.alloc_size, alloc_size);
966         CHECK_ALL_INFO(io.ntcreatex.out.size, size);
967         CHECK_ALL_INFO(io.ntcreatex.out.is_directory, directory);
968         CHECK_VAL(io.ntcreatex.out.file_type, FILE_TYPE_DISK);
969
970         /* check fields when the file already existed */
971         smbcli_close(cli->tree, fnum);
972         smbcli_unlink(cli->tree, fname);
973         fnum = create_complex_file(cli, tctx, fname);
974         if (fnum == -1) {
975                 ret = false;
976                 goto done;
977         }
978         smbcli_close(cli->tree, fnum);
979
980         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
981         status = smb_raw_open(cli->tree, tctx, &io);
982         CHECK_STATUS(status, NT_STATUS_OK);
983         fnum = io.ntcreatex.out.file.fnum;
984
985         CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
986         CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_EXISTED);
987         CHECK_NTTIME(io.ntcreatex.out.create_time, create_time);
988         CHECK_NTTIME(io.ntcreatex.out.access_time, access_time);
989         CHECK_NTTIME(io.ntcreatex.out.write_time, write_time);
990         CHECK_NTTIME(io.ntcreatex.out.change_time, change_time);
991         CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
992         CHECK_ALL_INFO(io.ntcreatex.out.alloc_size, alloc_size);
993         CHECK_ALL_INFO(io.ntcreatex.out.size, size);
994         CHECK_ALL_INFO(io.ntcreatex.out.is_directory, directory);
995         CHECK_VAL(io.ntcreatex.out.file_type, FILE_TYPE_DISK);
996         smbcli_close(cli->tree, fnum);
997
998         /* check no-recall - don't pull a file from tape on a HSM */
999         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_NO_RECALL;
1000         status = smb_raw_open(cli->tree, tctx, &io);
1001         CHECK_STATUS(status, NT_STATUS_OK);
1002         fnum = io.ntcreatex.out.file.fnum;
1003
1004         CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
1005         CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_EXISTED);
1006         CHECK_NTTIME(io.ntcreatex.out.create_time, create_time);
1007         CHECK_NTTIME(io.ntcreatex.out.access_time, access_time);
1008         CHECK_NTTIME(io.ntcreatex.out.write_time, write_time);
1009         CHECK_NTTIME(io.ntcreatex.out.change_time, change_time);
1010         CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
1011         CHECK_ALL_INFO(io.ntcreatex.out.alloc_size, alloc_size);
1012         CHECK_ALL_INFO(io.ntcreatex.out.size, size);
1013         CHECK_ALL_INFO(io.ntcreatex.out.is_directory, directory);
1014         CHECK_VAL(io.ntcreatex.out.file_type, FILE_TYPE_DISK);
1015         smbcli_close(cli->tree, fnum);
1016
1017         /* Check some create options (these all should be ignored) */
1018         for (i=0; i < 32; i++) {
1019                 uint32_t create_option = (1 << i) & NTCREATEX_OPTIONS_MUST_IGNORE_MASK;
1020                 if (create_option == 0) {
1021                         continue;
1022                 }
1023                 io.ntcreatex.in.create_options = create_option;
1024                 status = smb_raw_open(cli->tree, tctx, &io);
1025                 if (!NT_STATUS_IS_OK(status)) {
1026                         torture_warning(tctx, "ntcreatex create option 0x%08x "
1027                                 "gave %s - should give NT_STATUS_OK\n",
1028                                 create_option, nt_errstr(status));
1029                 }
1030                 CHECK_STATUS(status, NT_STATUS_OK);
1031                 fnum = io.ntcreatex.out.file.fnum;
1032
1033                 CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
1034                 CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_EXISTED);
1035                 CHECK_NTTIME(io.ntcreatex.out.create_time, create_time);
1036                 CHECK_NTTIME(io.ntcreatex.out.access_time, access_time);
1037                 CHECK_NTTIME(io.ntcreatex.out.write_time, write_time);
1038                 CHECK_NTTIME(io.ntcreatex.out.change_time, change_time);
1039                 CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
1040                 CHECK_ALL_INFO(io.ntcreatex.out.alloc_size, alloc_size);
1041                 CHECK_ALL_INFO(io.ntcreatex.out.size, size);
1042                 CHECK_ALL_INFO(io.ntcreatex.out.is_directory, directory);
1043                 CHECK_VAL(io.ntcreatex.out.file_type, FILE_TYPE_DISK);
1044                 smbcli_close(cli->tree, fnum);
1045         }
1046
1047         io.ntcreatex.in.file_attr = 0;
1048         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1049         io.ntcreatex.in.access_mask     = SEC_FLAG_MAXIMUM_ALLOWED;
1050
1051         /* Check for options that should return NOT_SUPPORTED, OK or INVALID_PARAMETER */
1052         ok_mask = 0;
1053         not_supported_mask = 0;
1054         invalid_parameter_mask = 0;
1055         not_a_directory_mask = 0;
1056         unexpected_mask = 0;
1057         for (i=0; i < 32; i++) {
1058                 uint32_t create_option = 1<<i;
1059                 if (create_option & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) {
1060                         continue;
1061                 }
1062                 io.ntcreatex.in.create_options = create_option;
1063                 status = smb_raw_open(cli->tree, tctx, &io);
1064                 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {
1065                         not_supported_mask |= create_option;
1066                 } else if (NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
1067                         ok_mask |= create_option;
1068                         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1069                 } else if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
1070                         invalid_parameter_mask |= create_option;
1071                 } else if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) {
1072                         not_a_directory_mask |= 1<<i;
1073                 } else {
1074                         unexpected_mask |= 1<<i;
1075                         torture_comment(tctx, "create option 0x%08x returned %s\n",
1076                                         create_option, nt_errstr(status));
1077                 }
1078         }
1079
1080         CHECK_VAL(ok_mask,                0x00efcfce);
1081         CHECK_VAL(not_a_directory_mask,   0x00000001);
1082         CHECK_VAL(not_supported_mask,     0x00002000);
1083         CHECK_VAL(invalid_parameter_mask, 0xff100030);
1084         CHECK_VAL(unexpected_mask,        0x00000000);
1085
1086         smbcli_unlink(cli->tree, fname);
1087
1088
1089         /* create a directory */
1090         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1091         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1092         io.ntcreatex.in.alloc_size = 0;
1093         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
1094         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1095         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1096         io.ntcreatex.in.create_options = 0;
1097         io.ntcreatex.in.fname = dname;
1098         fname = dname;
1099
1100         smbcli_rmdir(cli->tree, fname);
1101         smbcli_unlink(cli->tree, fname);
1102
1103         io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1104         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1105         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1106         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1107         status = smb_raw_open(cli->tree, tctx, &io);
1108         CHECK_STATUS(status, NT_STATUS_OK);
1109         fnum = io.ntcreatex.out.file.fnum;
1110
1111         CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
1112         CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_CREATED);
1113         CHECK_NTTIME(io.ntcreatex.out.create_time, create_time);
1114         CHECK_NTTIME(io.ntcreatex.out.access_time, access_time);
1115         CHECK_NTTIME(io.ntcreatex.out.write_time, write_time);
1116         CHECK_NTTIME(io.ntcreatex.out.change_time, change_time);
1117         CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
1118         CHECK_VAL(io.ntcreatex.out.attrib & ~FILE_ATTRIBUTE_NONINDEXED, 
1119                   FILE_ATTRIBUTE_DIRECTORY);
1120         CHECK_ALL_INFO(io.ntcreatex.out.alloc_size, alloc_size);
1121         CHECK_ALL_INFO(io.ntcreatex.out.size, size);
1122         CHECK_ALL_INFO(io.ntcreatex.out.is_directory, directory);
1123         CHECK_VAL(io.ntcreatex.out.is_directory, 1);
1124         CHECK_VAL(io.ntcreatex.out.size, 0);
1125         CHECK_VAL(io.ntcreatex.out.alloc_size, 0);
1126         CHECK_VAL(io.ntcreatex.out.file_type, FILE_TYPE_DISK);
1127         smbcli_unlink(cli->tree, fname);
1128         
1129
1130 done:
1131         smbcli_close(cli->tree, fnum);
1132         smbcli_deltree(cli->tree, BASEDIR);
1133
1134         return ret;
1135 }
1136
1137 /*
1138   test RAW_OPEN_NTCREATEX with an already opened and byte range locked file
1139
1140   I've got an application that does a similar sequence of ntcreate&x,
1141   locking&x and another ntcreate&x with
1142   open_disposition==NTCREATEX_DISP_OVERWRITE_IF. Windows 2003 allows the
1143   second open.
1144 */
1145 static bool test_ntcreatex_brlocked(struct torture_context *tctx, struct smbcli_state *cli)
1146 {
1147         union smb_open io, io1;
1148         union smb_lock io2;
1149         struct smb_lock_entry lock[1];
1150         const char *fname = BASEDIR "\\torture_ntcreatex.txt";
1151         NTSTATUS status;
1152         bool ret = true;
1153
1154         if (!torture_setup_dir(cli, BASEDIR)) {
1155                 return false;
1156         }
1157
1158         torture_comment(tctx, "Testing ntcreatex with a byte range locked file\n");
1159
1160         io.generic.level = RAW_OPEN_NTCREATEX;
1161         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
1162         io.ntcreatex.in.root_fid.fnum = 0;
1163         io.ntcreatex.in.access_mask = 0x2019f;
1164         io.ntcreatex.in.alloc_size = 0;
1165         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1166         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1167                 NTCREATEX_SHARE_ACCESS_WRITE;
1168         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1169         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
1170         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_IMPERSONATION;
1171         io.ntcreatex.in.security_flags = NTCREATEX_SECURITY_DYNAMIC |
1172                 NTCREATEX_SECURITY_ALL;
1173         io.ntcreatex.in.fname = fname;
1174
1175         status = smb_raw_open(cli->tree, tctx, &io);
1176         CHECK_STATUS(status, NT_STATUS_OK);
1177
1178         io2.lockx.level = RAW_LOCK_LOCKX;
1179         io2.lockx.in.file.fnum = io.ntcreatex.out.file.fnum;
1180         io2.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
1181         io2.lockx.in.timeout = 0;
1182         io2.lockx.in.ulock_cnt = 0;
1183         io2.lockx.in.lock_cnt = 1;
1184         lock[0].pid = cli->session->pid;
1185         lock[0].offset = 0;
1186         lock[0].count = 0x1;
1187         io2.lockx.in.locks = &lock[0];
1188         status = smb_raw_lock(cli->tree, &io2);
1189         CHECK_STATUS(status, NT_STATUS_OK);
1190
1191         io1.generic.level = RAW_OPEN_NTCREATEX;
1192         io1.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
1193         io1.ntcreatex.in.root_fid.fnum = 0;
1194         io1.ntcreatex.in.access_mask = 0x20196;
1195         io1.ntcreatex.in.alloc_size = 0;
1196         io1.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1197         io1.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1198                 NTCREATEX_SHARE_ACCESS_WRITE;
1199         io1.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
1200         io1.ntcreatex.in.create_options = 0;
1201         io1.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_IMPERSONATION;
1202         io1.ntcreatex.in.security_flags = NTCREATEX_SECURITY_DYNAMIC |
1203                 NTCREATEX_SECURITY_ALL;
1204         io1.ntcreatex.in.fname = fname;
1205
1206         status = smb_raw_open(cli->tree, tctx, &io1);
1207         CHECK_STATUS(status, NT_STATUS_OK);
1208
1209  done:
1210         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1211         smbcli_close(cli->tree, io1.ntcreatex.out.file.fnum);
1212         smbcli_deltree(cli->tree, BASEDIR);
1213         return ret;
1214 }
1215
1216 /*
1217   test RAW_OPEN_MKNEW
1218 */
1219 static bool test_mknew(struct torture_context *tctx, struct smbcli_state *cli)
1220 {
1221         union smb_open io;
1222         const char *fname = BASEDIR "\\torture_mknew.txt";
1223         NTSTATUS status;
1224         int fnum = -1;
1225         bool ret = true;
1226         time_t basetime = (time(NULL) + 3600*24*3) & ~1;
1227         union smb_fileinfo finfo;
1228
1229         if (!torture_setup_dir(cli, BASEDIR)) {
1230                 return false;
1231         }
1232
1233         io.mknew.level = RAW_OPEN_MKNEW;
1234         io.mknew.in.attrib = 0;
1235         io.mknew.in.write_time = 0;
1236         io.mknew.in.fname = fname;
1237         status = smb_raw_open(cli->tree, tctx, &io);
1238         CHECK_STATUS(status, NT_STATUS_OK);
1239         fnum = io.mknew.out.file.fnum;
1240
1241         status = smb_raw_open(cli->tree, tctx, &io);
1242         CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_COLLISION);
1243
1244         smbcli_close(cli->tree, fnum);
1245         smbcli_unlink(cli->tree, fname);
1246
1247         /* make sure write_time works */
1248         io.mknew.in.write_time = basetime;
1249         status = smb_raw_open(cli->tree, tctx, &io);
1250         CHECK_STATUS(status, NT_STATUS_OK);
1251         fnum = io.mknew.out.file.fnum;
1252         CHECK_TIME(basetime, write_time);
1253
1254         smbcli_close(cli->tree, fnum);
1255         smbcli_unlink(cli->tree, fname);
1256
1257         /* make sure file_attrs works */
1258         io.mknew.in.attrib = FILE_ATTRIBUTE_HIDDEN;
1259         status = smb_raw_open(cli->tree, tctx, &io);
1260         CHECK_STATUS(status, NT_STATUS_OK);
1261         fnum = io.mknew.out.file.fnum;
1262         CHECK_ALL_INFO(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_ARCHIVE, 
1263                        attrib & ~FILE_ATTRIBUTE_NONINDEXED);
1264         
1265 done:
1266         smbcli_close(cli->tree, fnum);
1267         smbcli_deltree(cli->tree, BASEDIR);
1268
1269         return ret;
1270 }
1271
1272
1273 /*
1274   test RAW_OPEN_CREATE
1275 */
1276 static bool test_create(struct torture_context *tctx, struct smbcli_state *cli)
1277 {
1278         union smb_open io;
1279         const char *fname = BASEDIR "\\torture_create.txt";
1280         NTSTATUS status;
1281         int fnum = -1;
1282         bool ret = true;
1283         time_t basetime = (time(NULL) + 3600*24*3) & ~1;
1284         union smb_fileinfo finfo;
1285
1286         if (!torture_setup_dir(cli, BASEDIR)) {
1287                 return false;
1288         }
1289
1290         io.create.level = RAW_OPEN_CREATE;
1291         io.create.in.attrib = 0;
1292         io.create.in.write_time = 0;
1293         io.create.in.fname = fname;
1294         status = smb_raw_open(cli->tree, tctx, &io);
1295         CHECK_STATUS(status, NT_STATUS_OK);
1296         fnum = io.create.out.file.fnum;
1297
1298         status = smb_raw_open(cli->tree, tctx, &io);
1299         CHECK_STATUS(status, NT_STATUS_OK);
1300
1301         smbcli_close(cli->tree, io.create.out.file.fnum);
1302         smbcli_close(cli->tree, fnum);
1303         smbcli_unlink(cli->tree, fname);
1304
1305         /* make sure write_time works */
1306         io.create.in.write_time = basetime;
1307         status = smb_raw_open(cli->tree, tctx, &io);
1308         CHECK_STATUS(status, NT_STATUS_OK);
1309         fnum = io.create.out.file.fnum;
1310         CHECK_TIME(basetime, write_time);
1311
1312         smbcli_close(cli->tree, fnum);
1313         smbcli_unlink(cli->tree, fname);
1314
1315         /* make sure file_attrs works */
1316         io.create.in.attrib = FILE_ATTRIBUTE_HIDDEN;
1317         status = smb_raw_open(cli->tree, tctx, &io);
1318         CHECK_STATUS(status, NT_STATUS_OK);
1319         fnum = io.create.out.file.fnum;
1320         CHECK_ALL_INFO(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_ARCHIVE, 
1321                        attrib & ~FILE_ATTRIBUTE_NONINDEXED);
1322         
1323 done:
1324         smbcli_close(cli->tree, fnum);
1325         smbcli_deltree(cli->tree, BASEDIR);
1326
1327         return ret;
1328 }
1329
1330
1331 /*
1332   test RAW_OPEN_CTEMP
1333 */
1334 static bool test_ctemp(struct torture_context *tctx, struct smbcli_state *cli)
1335 {
1336         union smb_open io;
1337         NTSTATUS status;
1338         int fnum = -1;
1339         bool ret = true;
1340         time_t basetime = (time(NULL) + 3600*24*3) & ~1;
1341         union smb_fileinfo finfo;
1342         const char *name, *fname = NULL;
1343
1344         if (!torture_setup_dir(cli, BASEDIR)) {
1345                 return false;
1346         }
1347
1348         io.ctemp.level = RAW_OPEN_CTEMP;
1349         io.ctemp.in.attrib = FILE_ATTRIBUTE_HIDDEN;
1350         io.ctemp.in.write_time = basetime;
1351         io.ctemp.in.directory = BASEDIR;
1352         status = smb_raw_open(cli->tree, tctx, &io);
1353         CHECK_STATUS(status, NT_STATUS_OK);
1354         fnum = io.ctemp.out.file.fnum;
1355
1356         name = io.ctemp.out.name;
1357
1358         finfo.generic.level = RAW_FILEINFO_NAME_INFO;
1359         finfo.generic.in.file.fnum = fnum;
1360         status = smb_raw_fileinfo(cli->tree, tctx, &finfo);
1361         CHECK_STATUS(status, NT_STATUS_OK);
1362
1363         fname = finfo.name_info.out.fname.s;
1364         torture_comment(tctx, "ctemp name=%s  real name=%s\n", name, fname);
1365
1366 done:
1367         smbcli_close(cli->tree, fnum);
1368         smbcli_deltree(cli->tree, BASEDIR);
1369
1370         return ret;
1371 }
1372
1373
1374 /*
1375   test chained RAW_OPEN_OPENX_READX
1376 */
1377 static bool test_chained(struct torture_context *tctx, struct smbcli_state *cli)
1378 {
1379         union smb_open io;
1380         const char *fname = BASEDIR "\\torture_chained.txt";
1381         NTSTATUS status;
1382         int fnum = -1;
1383         bool ret = true;
1384         const char *buf = "test";
1385         char buf2[4];
1386
1387         if (!torture_setup_dir(cli, BASEDIR)) {
1388                 return false;
1389         }
1390
1391         fnum = create_complex_file(cli, tctx, fname);
1392
1393         smbcli_write(cli->tree, fnum, 0, buf, 0, sizeof(buf));
1394
1395         smbcli_close(cli->tree, fnum);  
1396
1397         io.openxreadx.level = RAW_OPEN_OPENX_READX;
1398         io.openxreadx.in.fname = fname;
1399         io.openxreadx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
1400         io.openxreadx.in.open_mode = OPENX_MODE_ACCESS_RDWR;
1401         io.openxreadx.in.open_func = OPENX_OPEN_FUNC_OPEN;
1402         io.openxreadx.in.search_attrs = 0;
1403         io.openxreadx.in.file_attrs = 0;
1404         io.openxreadx.in.write_time = 0;
1405         io.openxreadx.in.size = 1024*1024;
1406         io.openxreadx.in.timeout = 0;
1407         
1408         io.openxreadx.in.offset = 0;
1409         io.openxreadx.in.mincnt = sizeof(buf);
1410         io.openxreadx.in.maxcnt = sizeof(buf);
1411         io.openxreadx.in.remaining = 0;
1412         io.openxreadx.out.data = (uint8_t *)buf2;
1413
1414         status = smb_raw_open(cli->tree, tctx, &io);
1415         CHECK_STATUS(status, NT_STATUS_OK);
1416         fnum = io.openxreadx.out.file.fnum;
1417
1418         if (memcmp(buf, buf2, sizeof(buf)) != 0) {
1419                 torture_result(tctx, TORTURE_FAIL,
1420                         "wrong data in reply buffer\n");
1421                 ret = false;
1422         }
1423
1424 done:
1425         smbcli_close(cli->tree, fnum);
1426         smbcli_deltree(cli->tree, BASEDIR);
1427
1428         return ret;
1429 }
1430
1431 /*
1432   test RAW_OPEN_OPENX without a leading slash on the path.
1433   NetApp filers are known to fail on this.
1434   
1435 */
1436 static bool test_no_leading_slash(struct torture_context *tctx, struct smbcli_state *cli)
1437 {
1438         union smb_open io;
1439         const char *fname = BASEDIR "\\torture_no_leading_slash.txt";
1440         NTSTATUS status;
1441         int fnum = -1;
1442         bool ret = true;
1443         const char *buf = "test";
1444
1445         if (!torture_setup_dir(cli, BASEDIR)) {
1446                 return false;
1447         }
1448
1449         smbcli_unlink(cli->tree, fname);
1450
1451         /* Create the file */
1452         fnum = create_complex_file(cli, tctx, fname);
1453         smbcli_write(cli->tree, fnum, 0, buf, 0, sizeof(buf));
1454         smbcli_close(cli->tree, fnum);  
1455
1456         /* Prepare to open the file using path without leading slash */
1457         io.openx.level = RAW_OPEN_OPENX;
1458         io.openx.in.fname = fname + 1;
1459         io.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
1460         io.openx.in.open_mode = OPENX_MODE_ACCESS_RDWR;
1461         io.openx.in.open_func = OPENX_OPEN_FUNC_OPEN;
1462         io.openx.in.search_attrs = 0;
1463         io.openx.in.file_attrs = 0;
1464         io.openx.in.write_time = 0;
1465         io.openx.in.size = 1024*1024;
1466         io.openx.in.timeout = 0;
1467
1468         status = smb_raw_open(cli->tree, tctx, &io);
1469         CHECK_STATUS(status, NT_STATUS_OK);
1470         fnum = io.openx.out.file.fnum;
1471
1472 done:
1473         smbcli_close(cli->tree, fnum);
1474         smbcli_deltree(cli->tree, BASEDIR);
1475
1476         return ret;
1477 }
1478
1479 /*
1480   test RAW_OPEN_OPENX against an existing directory to
1481   ensure it returns NT_STATUS_FILE_IS_A_DIRECTORY.
1482   Samba 3.2.0 - 3.2.6 are known to fail this.
1483   
1484 */
1485 static bool test_openx_over_dir(struct torture_context *tctx, struct smbcli_state *cli)
1486 {
1487         union smb_open io;
1488         const char *fname = BASEDIR "\\openx_over_dir";
1489         NTSTATUS status;
1490         int d_fnum = -1;
1491         int fnum = -1;
1492         bool ret = true;
1493
1494         if (!torture_setup_dir(cli, BASEDIR)) {
1495                 return false;
1496         }
1497
1498         /* Create the Directory */
1499         status = create_directory_handle(cli->tree, fname, &d_fnum);
1500         smbcli_close(cli->tree, d_fnum);        
1501
1502         /* Prepare to open the file over the directory. */
1503         io.openx.level = RAW_OPEN_OPENX;
1504         io.openx.in.fname = fname;
1505         io.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
1506         io.openx.in.open_mode = OPENX_MODE_ACCESS_RDWR;
1507         io.openx.in.open_func = OPENX_OPEN_FUNC_OPEN;
1508         io.openx.in.search_attrs = 0;
1509         io.openx.in.file_attrs = 0;
1510         io.openx.in.write_time = 0;
1511         io.openx.in.size = 1024*1024;
1512         io.openx.in.timeout = 0;
1513
1514         status = smb_raw_open(cli->tree, tctx, &io);
1515         CHECK_STATUS(status, NT_STATUS_FILE_IS_A_DIRECTORY);
1516         fnum = io.openx.out.file.fnum;
1517
1518 done:
1519         smbcli_close(cli->tree, fnum);
1520         smbcli_deltree(cli->tree, BASEDIR);
1521
1522         return ret;
1523 }
1524
1525
1526 /* A little torture test to expose a race condition in Samba 3.0.20 ... :-) */
1527
1528 static bool test_raw_open_multi(struct torture_context *tctx, struct smbcli_state *cli_ignored)
1529 {
1530         struct smbcli_state *cli;
1531         TALLOC_CTX *mem_ctx = talloc_init("torture_test_oplock_multi");
1532         const char *fname = "\\test_oplock.dat";
1533         NTSTATUS status;
1534         bool ret = true;
1535         union smb_open io;
1536         struct smbcli_state **clients;
1537         struct smbcli_request **requests;
1538         union smb_open *ios;
1539         const char *host = torture_setting_string(tctx, "host", NULL);
1540         const char *share = torture_setting_string(tctx, "share", NULL);
1541         int i, num_files = 3;
1542         int num_ok = 0;
1543         int num_collision = 0;
1544         
1545         clients = talloc_array(mem_ctx, struct smbcli_state *, num_files);
1546         requests = talloc_array(mem_ctx, struct smbcli_request *, num_files);
1547         ios = talloc_array(mem_ctx, union smb_open, num_files);
1548         if ((tctx->ev == NULL) || (clients == NULL) || (requests == NULL) ||
1549             (ios == NULL)) {
1550                 torture_result(tctx, TORTURE_FAIL, "(%s): talloc failed\n",
1551                                 __location__);
1552                 return false;
1553         }
1554
1555         if (!torture_open_connection_share(mem_ctx, &cli, tctx, host, share, tctx->ev)) {
1556                 return false;
1557         }
1558
1559         cli->tree->session->transport->options.request_timeout = 60;
1560
1561         for (i=0; i<num_files; i++) {
1562                 if (!torture_open_connection_share(mem_ctx, &(clients[i]),
1563                                                    tctx, host, share, tctx->ev)) {
1564                         torture_result(tctx, TORTURE_FAIL,
1565                                        "(%s): Could not open %d'th connection\n",
1566                                        __location__, i);
1567                         return false;
1568                 }
1569                 clients[i]->tree->session->transport->options.request_timeout = 60;
1570         }
1571
1572         /* cleanup */
1573         smbcli_unlink(cli->tree, fname);
1574
1575         /*
1576           base ntcreatex parms
1577         */
1578         io.generic.level = RAW_OPEN_NTCREATEX;
1579         io.ntcreatex.in.root_fid.fnum = 0;
1580         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1581         io.ntcreatex.in.alloc_size = 0;
1582         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1583         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1584                 NTCREATEX_SHARE_ACCESS_WRITE|
1585                 NTCREATEX_SHARE_ACCESS_DELETE;
1586         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1587         io.ntcreatex.in.create_options = 0;
1588         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1589         io.ntcreatex.in.security_flags = 0;
1590         io.ntcreatex.in.fname = fname;
1591         io.ntcreatex.in.flags = 0;
1592
1593         for (i=0; i<num_files; i++) {
1594                 ios[i] = io;
1595                 requests[i] = smb_raw_open_send(clients[i]->tree, &ios[i]);
1596                 if (requests[i] == NULL) {
1597                         torture_result(tctx, TORTURE_FAIL,
1598                                 "(%s): could not send %d'th request\n",
1599                                 __location__, i);
1600                         return false;
1601                 }
1602         }
1603
1604         torture_comment(tctx, "waiting for replies\n");
1605         while (1) {
1606                 bool unreplied = false;
1607                 for (i=0; i<num_files; i++) {
1608                         if (requests[i] == NULL) {
1609                                 continue;
1610                         }
1611                         if (requests[i]->state < SMBCLI_REQUEST_DONE) {
1612                                 unreplied = true;
1613                                 break;
1614                         }
1615                         status = smb_raw_open_recv(requests[i], mem_ctx,
1616                                                    &ios[i]);
1617
1618                         torture_comment(tctx, "File %d returned status %s\n", i,
1619                                   nt_errstr(status));
1620
1621                         if (NT_STATUS_IS_OK(status)) {
1622                                 num_ok += 1;
1623                         } 
1624
1625                         if (NT_STATUS_EQUAL(status,
1626                                             NT_STATUS_OBJECT_NAME_COLLISION)) {
1627                                 num_collision += 1;
1628                         }
1629
1630                         requests[i] = NULL;
1631                 }
1632                 if (!unreplied) {
1633                         break;
1634                 }
1635
1636                 if (tevent_loop_once(tctx->ev) != 0) {
1637                         torture_result(tctx, TORTURE_FAIL,
1638                                 "(%s): tevent_loop_once failed\n", __location__);
1639                         return false;
1640                 }
1641         }
1642
1643         if ((num_ok != 1) || (num_ok + num_collision != num_files)) {
1644                 ret = false;
1645         }
1646
1647         for (i=0; i<num_files; i++) {
1648                 torture_close_connection(clients[i]);
1649         }
1650         talloc_free(mem_ctx);
1651         return ret;
1652 }
1653
1654 /*
1655   test opening for delete on a read-only attribute file.
1656 */
1657 static bool test_open_for_delete(struct torture_context *tctx, struct smbcli_state *cli)
1658 {
1659         union smb_open io;
1660         union smb_fileinfo finfo;
1661         const char *fname = BASEDIR "\\torture_open_for_delete.txt";
1662         NTSTATUS status;
1663         int fnum = -1;
1664         bool ret = true;
1665
1666         if (!torture_setup_dir(cli, BASEDIR)) {
1667                 return false;
1668         }
1669
1670         /* reasonable default parameters */
1671         io.generic.level = RAW_OPEN_NTCREATEX;
1672         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
1673         io.ntcreatex.in.root_fid.fnum = 0;
1674         io.ntcreatex.in.alloc_size = 0;
1675         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1676         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_READONLY;
1677         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1678         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1679         io.ntcreatex.in.create_options = 0;
1680         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1681         io.ntcreatex.in.security_flags = 0;
1682         io.ntcreatex.in.fname = fname;
1683
1684         /* Create the readonly file. */
1685
1686         status = smb_raw_open(cli->tree, tctx, &io);
1687         CHECK_STATUS(status, NT_STATUS_OK);
1688         fnum = io.ntcreatex.out.file.fnum;
1689
1690         CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
1691         io.ntcreatex.in.create_options = 0;
1692         CHECK_VAL(io.ntcreatex.out.create_action, NTCREATEX_ACTION_CREATED);
1693         CHECK_ALL_INFO(io.ntcreatex.out.attrib, attrib);
1694         smbcli_close(cli->tree, fnum);
1695
1696         /* Now try and open for delete only - should succeed. */
1697         io.ntcreatex.in.access_mask = SEC_STD_DELETE;
1698         io.ntcreatex.in.file_attr = 0;
1699         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
1700         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1701         status = smb_raw_open(cli->tree, tctx, &io);
1702         CHECK_STATUS(status, NT_STATUS_OK);
1703
1704         smbcli_unlink(cli->tree, fname);
1705
1706 done:
1707         smbcli_close(cli->tree, fnum);
1708         smbcli_deltree(cli->tree, BASEDIR);
1709
1710         return ret;
1711 }
1712
1713 /*
1714   test chained RAW_OPEN_NTCREATEX_READX
1715   Send chained NTCREATEX_READX on a file that doesn't exist, then create
1716   the file and try again.
1717 */
1718 static bool test_chained_ntcreatex_readx(struct torture_context *tctx, struct smbcli_state *cli)
1719 {
1720         TALLOC_CTX *mem_ctx = talloc_new(tctx);
1721         union smb_open io;
1722         const char *fname = BASEDIR "\\torture_chained.txt";
1723         NTSTATUS status;
1724         int fnum = -1;
1725         bool ret = true;
1726         const char *buf = "test";
1727         char buf2[4];
1728
1729         if (!torture_setup_dir(cli, BASEDIR)) {
1730                 return false;
1731         }
1732
1733         torture_comment(tctx, "Checking RAW_NTCREATEX_READX chained on "
1734                               "non-existant file \n");
1735
1736         /* ntcreatex parameters */
1737         io.generic.level = RAW_OPEN_NTCREATEX_READX;
1738         io.ntcreatexreadx.in.flags = 0;
1739         io.ntcreatexreadx.in.root_fid.fnum = 0;
1740         io.ntcreatexreadx.in.access_mask = SEC_FILE_READ_DATA;
1741         io.ntcreatexreadx.in.alloc_size = 0;
1742         io.ntcreatexreadx.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1743         io.ntcreatexreadx.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1744                 NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
1745         io.ntcreatexreadx.in.open_disposition = NTCREATEX_DISP_OPEN;
1746         io.ntcreatexreadx.in.create_options = 0;
1747         io.ntcreatexreadx.in.impersonation = NTCREATEX_IMPERSONATION_IMPERSONATION;
1748         io.ntcreatexreadx.in.security_flags = 0;
1749         io.ntcreatexreadx.in.fname = fname;
1750
1751         /* readx parameters */
1752         io.ntcreatexreadx.in.offset = 0;
1753         io.ntcreatexreadx.in.mincnt = sizeof(buf);
1754         io.ntcreatexreadx.in.maxcnt = sizeof(buf);
1755         io.ntcreatexreadx.in.remaining = 0;
1756         io.ntcreatexreadx.out.data = (uint8_t *)buf2;
1757
1758         /* try to open the non-existant file */
1759         status = smb_raw_open(cli->tree, mem_ctx, &io);
1760         CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1761         fnum = io.ntcreatexreadx.out.file.fnum;
1762
1763         smbcli_close(cli->tree, fnum);
1764         smbcli_unlink(cli->tree, fname);
1765
1766         torture_comment(tctx, "Checking RAW_NTCREATEX_READX chained on "
1767                               "existing file \n");
1768
1769         fnum = create_complex_file(cli, mem_ctx, fname);
1770         smbcli_write(cli->tree, fnum, 0, buf, 0, sizeof(buf));
1771         smbcli_close(cli->tree, fnum);
1772
1773         status = smb_raw_open(cli->tree, mem_ctx, &io);
1774         CHECK_STATUS(status, NT_STATUS_OK);
1775         fnum = io.ntcreatexreadx.out.file.fnum;
1776
1777         if (memcmp(buf, buf2, sizeof(buf)) != 0) {
1778                 torture_result(tctx, TORTURE_FAIL,
1779                         "(%s): wrong data in reply buffer\n", __location__);
1780                 ret = false;
1781         }
1782
1783 done:
1784         smbcli_close(cli->tree, fnum);
1785         smbcli_deltree(cli->tree, BASEDIR);
1786         talloc_free(mem_ctx);
1787
1788         return ret;
1789 }
1790
1791 static bool test_ntcreatex_opendisp_dir(struct torture_context *tctx,
1792                                         struct smbcli_state *cli)
1793 {
1794         const char *dname = BASEDIR "\\torture_ntcreatex_opendisp_dir";
1795         NTSTATUS status;
1796         bool ret = true;
1797         int i;
1798         struct {
1799                 uint32_t open_disp;
1800                 bool dir_exists;
1801                 NTSTATUS correct_status;
1802         } open_funcs_dir[] = {
1803                 { NTCREATEX_DISP_SUPERSEDE,     true,  NT_STATUS_INVALID_PARAMETER },
1804                 { NTCREATEX_DISP_SUPERSEDE,     false, NT_STATUS_INVALID_PARAMETER },
1805                 { NTCREATEX_DISP_OPEN,          true,  NT_STATUS_OK },
1806                 { NTCREATEX_DISP_OPEN,          false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
1807                 { NTCREATEX_DISP_CREATE,        true,  NT_STATUS_OBJECT_NAME_COLLISION },
1808                 { NTCREATEX_DISP_CREATE,        false, NT_STATUS_OK },
1809                 { NTCREATEX_DISP_OPEN_IF,       true,  NT_STATUS_OK },
1810                 { NTCREATEX_DISP_OPEN_IF,       false, NT_STATUS_OK },
1811                 { NTCREATEX_DISP_OVERWRITE,     true,  NT_STATUS_INVALID_PARAMETER },
1812                 { NTCREATEX_DISP_OVERWRITE,     false, NT_STATUS_INVALID_PARAMETER },
1813                 { NTCREATEX_DISP_OVERWRITE_IF,  true,  NT_STATUS_INVALID_PARAMETER },
1814                 { NTCREATEX_DISP_OVERWRITE_IF,  false, NT_STATUS_INVALID_PARAMETER },
1815                 { 6,                            true,  NT_STATUS_INVALID_PARAMETER },
1816                 { 6,                            false, NT_STATUS_INVALID_PARAMETER },
1817         };
1818         union smb_open io;
1819
1820         ZERO_STRUCT(io);
1821         io.generic.level = RAW_OPEN_NTCREATEX;
1822         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
1823         io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1824         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
1825         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1826         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1827         io.ntcreatex.in.fname = dname;
1828
1829         if (!torture_setup_dir(cli, BASEDIR)) {
1830                 return false;
1831         }
1832
1833         smbcli_rmdir(cli->tree, dname);
1834         smbcli_unlink(cli->tree, dname);
1835
1836         /* test the open disposition for directories */
1837         torture_comment(tctx, "Testing open dispositions for directories...\n");
1838
1839         for (i=0; i<ARRAY_SIZE(open_funcs_dir); i++) {
1840                 if (open_funcs_dir[i].dir_exists) {
1841                         status = smbcli_mkdir(cli->tree, dname);
1842                         if (!NT_STATUS_IS_OK(status)) {
1843                                 torture_result(tctx, TORTURE_FAIL,
1844                                         "(%s): Failed to make directory "
1845                                         "%s - %s\n", __location__, dname,
1846                                         smbcli_errstr(cli->tree));
1847                                 ret = false;
1848                                 goto done;
1849                         }
1850                 }
1851
1852                 io.ntcreatex.in.open_disposition = open_funcs_dir[i].open_disp;
1853                 status = smb_raw_open(cli->tree, tctx, &io);
1854                 if (!NT_STATUS_EQUAL(status, open_funcs_dir[i].correct_status)) {
1855                         torture_result(tctx, TORTURE_FAIL,
1856                                 "(%s) incorrect status %s should be %s "
1857                                 "(i=%d dir_exists=%d open_disp=%d)\n",
1858                                 __location__, nt_errstr(status),
1859                                 nt_errstr(open_funcs_dir[i].correct_status),
1860                                 i, (int)open_funcs_dir[i].dir_exists,
1861                                 (int)open_funcs_dir[i].open_disp);
1862                         ret = false;
1863                 }
1864                 if (NT_STATUS_IS_OK(status) || open_funcs_dir[i].dir_exists) {
1865                         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1866                         smbcli_rmdir(cli->tree, dname);
1867                 }
1868         }
1869
1870 done:
1871         smbcli_deltree(cli->tree, BASEDIR);
1872
1873         return ret;
1874 }
1875
1876 /**
1877  * Test what happens when trying to open a file with directory parameters and
1878  * vice-versa.  Also test that NTCREATEX_OPTIONS_DIRECTORY is treated as
1879  * mandatory and FILE_ATTRIBUTE_DIRECTORY is advisory for directory
1880  * creation/opening.
1881  */
1882 static bool test_ntcreatexdir(struct torture_context *tctx,
1883     struct smbcli_state *cli)
1884 {
1885         union smb_open io;
1886         const char *fname = BASEDIR "\\torture_ntcreatex.txt";
1887         const char *dname = BASEDIR "\\torture_ntcreatex_dir";
1888         NTSTATUS status;
1889         int i;
1890
1891         struct {
1892                 uint32_t open_disp;
1893                 uint32_t file_attr;
1894                 uint32_t create_options;
1895                 NTSTATUS correct_status;
1896         } open_funcs[] = {
1897                 { NTCREATEX_DISP_SUPERSEDE,     0, NTCREATEX_OPTIONS_DIRECTORY,
1898                   NT_STATUS_INVALID_PARAMETER },
1899                 { NTCREATEX_DISP_OPEN,          0, NTCREATEX_OPTIONS_DIRECTORY,
1900                   NT_STATUS_OBJECT_NAME_NOT_FOUND },
1901                 { NTCREATEX_DISP_CREATE,        0, NTCREATEX_OPTIONS_DIRECTORY,
1902                   NT_STATUS_OK },
1903                 { NTCREATEX_DISP_OPEN_IF,       0, NTCREATEX_OPTIONS_DIRECTORY,
1904                   NT_STATUS_OK },
1905                 { NTCREATEX_DISP_OVERWRITE,     0, NTCREATEX_OPTIONS_DIRECTORY,
1906                   NT_STATUS_INVALID_PARAMETER },
1907                 { NTCREATEX_DISP_OVERWRITE_IF,  0, NTCREATEX_OPTIONS_DIRECTORY,
1908                   NT_STATUS_INVALID_PARAMETER },
1909                 { NTCREATEX_DISP_SUPERSEDE,     FILE_ATTRIBUTE_DIRECTORY, 0,
1910                   NT_STATUS_OK },
1911                 { NTCREATEX_DISP_OPEN,          FILE_ATTRIBUTE_DIRECTORY, 0,
1912                   NT_STATUS_OBJECT_NAME_NOT_FOUND },
1913                 { NTCREATEX_DISP_CREATE,        FILE_ATTRIBUTE_DIRECTORY, 0,
1914                   NT_STATUS_OK },
1915                 { NTCREATEX_DISP_OPEN_IF,       FILE_ATTRIBUTE_DIRECTORY, 0,
1916                   NT_STATUS_OK },
1917                 { NTCREATEX_DISP_OVERWRITE,     FILE_ATTRIBUTE_DIRECTORY, 0,
1918                   NT_STATUS_OBJECT_NAME_NOT_FOUND },
1919                 { NTCREATEX_DISP_OVERWRITE_IF,  FILE_ATTRIBUTE_DIRECTORY, 0,
1920                   NT_STATUS_OK },
1921
1922         };
1923
1924         if (!torture_setup_dir(cli, BASEDIR)) {
1925                 return false;
1926         }
1927
1928         /* setup some base params. */
1929         io.generic.level = RAW_OPEN_NTCREATEX;
1930         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
1931         io.ntcreatex.in.root_fid.fnum = 0;
1932         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1933         io.ntcreatex.in.alloc_size = 0;
1934         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1935         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1936         io.ntcreatex.in.security_flags = 0;
1937         io.ntcreatex.in.fname = fname;
1938
1939         /*
1940          * Test the validity checking for create dispositions, which is done
1941          * against the requested parameters rather than what's actually on
1942          * disk.
1943          */
1944         for (i=0; i<ARRAY_SIZE(open_funcs); i++) {
1945                 io.ntcreatex.in.open_disposition = open_funcs[i].open_disp;
1946                 io.ntcreatex.in.file_attr = open_funcs[i].file_attr;
1947                 io.ntcreatex.in.create_options = open_funcs[i].create_options;
1948                 status = smb_raw_open(cli->tree, tctx, &io);
1949                 if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
1950                         torture_result(tctx, TORTURE_FAIL,
1951                                 "(%s) incorrect status %s should be %s "
1952                                 "(i=%d open_disp=%d)\n",
1953                                 __location__, nt_errstr(status),
1954                                 nt_errstr(open_funcs[i].correct_status),
1955                                 i, (int)open_funcs[i].open_disp);
1956                         return false;
1957                 }
1958                 /* Close and delete the file. */
1959                 if (NT_STATUS_IS_OK(status)) {
1960                         if (open_funcs[i].create_options != 0) {
1961                                 /* out attrib should be a directory. */
1962                                 torture_assert_int_equal(tctx,
1963                                     io.ntcreatex.out.attrib,
1964                                     FILE_ATTRIBUTE_DIRECTORY, "should have "
1965                                     "created a directory");
1966
1967                                 smbcli_close(cli->tree,
1968                                     io.ntcreatex.out.file.fnum);
1969
1970                                 /* Make sure unlink fails. */
1971                                 status = smbcli_unlink(cli->tree, fname);
1972                                 torture_assert_ntstatus_equal(tctx, status,
1973                                     NT_STATUS_FILE_IS_A_DIRECTORY,
1974                                     "unlink should fail for a directory");
1975
1976                                 status = smbcli_rmdir(cli->tree, fname);
1977                                 torture_assert_ntstatus_ok(tctx, status,
1978                                     "rmdir failed");
1979                         } else {
1980                                 torture_assert_int_equal(tctx,
1981                                     io.ntcreatex.out.attrib,
1982                                     FILE_ATTRIBUTE_ARCHIVE, "should not have "
1983                                     "created a directory");
1984
1985                                 smbcli_close(cli->tree,
1986                                     io.ntcreatex.out.file.fnum);
1987
1988                                 /* Make sure rmdir fails. */
1989                                 status = smbcli_rmdir(cli->tree, fname);
1990                                 torture_assert_ntstatus_equal(tctx, status,
1991                                     NT_STATUS_NOT_A_DIRECTORY,
1992                                     "rmdir should fail for a file");
1993
1994                                 status = smbcli_unlink(cli->tree, fname);
1995                                 torture_assert_ntstatus_ok(tctx, status,
1996                                     "unlink failed");
1997                         }
1998                 }
1999         }
2000
2001         /* Create a file. */
2002         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2003         io.ntcreatex.in.create_options = 0;
2004         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
2005         status = smb_raw_open(cli->tree, tctx, &io);
2006         torture_assert_ntstatus_ok(tctx, status, "Failed to create file.");
2007         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
2008
2009         /* Try and open the file with file_attr_dir and check the error. */
2010         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
2011         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
2012
2013         status = smb_raw_open(cli->tree, tctx, &io);
2014         torture_assert_ntstatus_ok(tctx, status, "FILE_ATTRIBUTE_DIRECTORY "
2015             "doesn't produce a hard failure.");
2016         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
2017
2018         /* Try and open file with createx_option_dir and check the error. */
2019         io.ntcreatex.in.file_attr = 0;
2020         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
2021
2022         status = smb_raw_open(cli->tree, tctx, &io);
2023         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NOT_A_DIRECTORY,
2024             "NTCREATEX_OPTIONS_DIRECTORY will a file from being opened.");
2025         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
2026
2027         /* Delete the file and move onto directory testing. */
2028         smbcli_unlink(cli->tree, fname);
2029
2030         /* Now try some tests on a directory. */
2031         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
2032         io.ntcreatex.in.file_attr = 0;
2033         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
2034         io.ntcreatex.in.fname = dname;
2035
2036         status = smb_raw_open(cli->tree, tctx, &io);
2037         torture_assert_ntstatus_ok(tctx, status, "Failed to create dir.");
2038
2039         /* out attrib should be a directory. */
2040         torture_assert_int_equal(tctx, io.ntcreatex.out.attrib,
2041             FILE_ATTRIBUTE_DIRECTORY, "should have created a directory");
2042
2043         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
2044
2045         /* Try and open it with normal attr and check the error. */
2046         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2047         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
2048
2049         status = smb_raw_open(cli->tree, tctx, &io);
2050         torture_assert_ntstatus_ok(tctx, status, "FILE_ATTRIBUTE_NORMAL "
2051             "doesn't produce a hard failure.");
2052         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
2053
2054         /* Try and open it with file create_options and check the error. */
2055         io.ntcreatex.in.file_attr = 0;
2056         io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
2057
2058         status = smb_raw_open(cli->tree, tctx, &io);
2059         torture_assert_ntstatus_equal(tctx, status,
2060             NT_STATUS_FILE_IS_A_DIRECTORY,
2061             "NTCREATEX_OPTIONS_NON_DIRECTORY_FILE should be returned ");
2062         smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
2063
2064         smbcli_deltree(cli->tree, BASEDIR);
2065
2066         return true;
2067 }
2068
2069 /* basic testing of all RAW_OPEN_* calls
2070 */
2071 struct torture_suite *torture_raw_open(TALLOC_CTX *mem_ctx)
2072 {
2073         struct torture_suite *suite = torture_suite_create(mem_ctx, "open");
2074
2075         torture_suite_add_1smb_test(suite, "brlocked", test_ntcreatex_brlocked);
2076         torture_suite_add_1smb_test(suite, "open", test_open);
2077         torture_suite_add_1smb_test(suite, "open-multi", test_raw_open_multi);
2078         torture_suite_add_1smb_test(suite, "openx", test_openx);
2079         torture_suite_add_1smb_test(suite, "ntcreatex", test_ntcreatex);
2080         torture_suite_add_1smb_test(suite, "nttrans-create", test_nttrans_create);
2081         torture_suite_add_1smb_test(suite, "t2open", test_t2open);
2082         torture_suite_add_1smb_test(suite, "mknew", test_mknew);
2083         torture_suite_add_1smb_test(suite, "create", test_create);
2084         torture_suite_add_1smb_test(suite, "ctemp", test_ctemp);
2085         torture_suite_add_1smb_test(suite, "chained-openx", test_chained);
2086         torture_suite_add_1smb_test(suite, "chained-ntcreatex", test_chained_ntcreatex_readx);
2087         torture_suite_add_1smb_test(suite, "no-leading-slash", test_no_leading_slash);
2088         torture_suite_add_1smb_test(suite, "openx-over-dir", test_openx_over_dir);
2089         torture_suite_add_1smb_test(suite, "open-for-delete", test_open_for_delete);
2090         torture_suite_add_1smb_test(suite, "opendisp-dir", test_ntcreatex_opendisp_dir);
2091         torture_suite_add_1smb_test(suite, "ntcreatedir", test_ntcreatexdir);
2092
2093         return suite;
2094 }