?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
epm: Increase debug level for already registered endpoints.
[Samba.git] / source4 / torture / basic / delete.c
blobe3d830da627b7a96b8a23c9dc12a16d9dea2bad8
1 /*
2 Unix SMB/CIFS implementation.
3
4 delete on close testing
5
6 Copyright (C) Andrew Tridgell 2003
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "libcli/libcli.h"
24 #include "torture/util.h"
25 #include "system/filesys.h"
26 #include "libcli/raw/raw_proto.h"
27
28 #include "torture/raw/proto.h"
29 #include "torture/basic/proto.h"
30
31 static bool check_delete_on_close(struct torture_context *tctx,
32 struct smbcli_state *cli, int fnum,
33 const char *fname, bool expect_it,
34 const char *where)
35 {
36 union smb_search_data data;
37 NTSTATUS status;
38
39 time_t c_time, a_time, m_time;
40 size_t size;
41 uint16_t mode;
42
43 status = torture_single_search(cli, tctx,
44 fname,
45 RAW_SEARCH_TRANS2,
46 RAW_SEARCH_DATA_FULL_DIRECTORY_INFO,
47 FILE_ATTRIBUTE_DIRECTORY,
48 &data);
49 torture_assert_ntstatus_ok(tctx, status,
50 talloc_asprintf(tctx, "single_search failed (%s)", where));
51
52 if (fnum != -1) {
53 union smb_fileinfo io;
54 int nlink = expect_it ? 0 : 1;
55
56 io.all_info.level = RAW_FILEINFO_ALL_INFO;
57 io.all_info.in.file.fnum = fnum;
58
59 status = smb_raw_fileinfo(cli->tree, tctx, &io);
60 torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx,
61 "qfileinfo failed (%s)", where));
62
63 torture_assert(tctx, expect_it == io.all_info.out.delete_pending,
64 talloc_asprintf(tctx,
65 "%s - Expected del_on_close flag %d, qfileinfo/all_info gave %d",
66 where, expect_it, io.all_info.out.delete_pending));
67
68 torture_assert(tctx, nlink == io.all_info.out.nlink,
69 talloc_asprintf(tctx,
70 "%s - Expected nlink %d, qfileinfo/all_info gave %d",
71 where, nlink, io.all_info.out.nlink));
72
73 io.standard_info.level = RAW_FILEINFO_STANDARD_INFO;
74 io.standard_info.in.file.fnum = fnum;
75
76 status = smb_raw_fileinfo(cli->tree, tctx, &io);
77 torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "qpathinfo failed (%s)", where));
78
79 torture_assert(tctx, expect_it == io.standard_info.out.delete_pending,
80 talloc_asprintf(tctx, "%s - Expected del_on_close flag %d, qfileinfo/standard_info gave %d\n",
81 where, expect_it, io.standard_info.out.delete_pending));
82
83 torture_assert(tctx, nlink == io.standard_info.out.nlink,
84 talloc_asprintf(tctx, "%s - Expected nlink %d, qfileinfo/standard_info gave %d",
85 where, nlink, io.all_info.out.nlink));
86 }
87
88 status = smbcli_qpathinfo(cli->tree, fname,
89 &c_time, &a_time, &m_time,
90 &size, &mode);
91
92 if (expect_it) {
93 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_DELETE_PENDING,
94 "qpathinfo did not give correct error code");
95 } else {
96 torture_assert_ntstatus_ok(tctx, status,
97 talloc_asprintf(tctx, "qpathinfo failed (%s)", where));
98 }
99
100 return true;
101 }
102
103 #define CHECK_STATUS(_cli, _expected) \
104 torture_assert_ntstatus_equal(tctx, _cli->tree->session->transport->error.e.nt_status, _expected, \
105 "Incorrect status")
106
107 static const char *fname = "\\delete.file";
108 static const char *fname_new = "\\delete.new";
109 static const char *dname = "\\delete.dir";
110
111 static void del_clean_area(struct smbcli_state *cli1, struct smbcli_state *cli2)
112 {
113 smb_raw_exit(cli1->session);
114 smb_raw_exit(cli2->session);
115
116 smbcli_deltree(cli1->tree, dname);
117 smbcli_setatr(cli1->tree, fname, 0, 0);
118 smbcli_unlink(cli1->tree, fname);
119 smbcli_setatr(cli1->tree, fname_new, 0, 0);
120 smbcli_unlink(cli1->tree, fname_new);
121 }
122
123 /* Test 1 - this should delete the file on close. */
124
125 static bool deltest1(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
126 {
127 int fnum1 = -1;
128
129 del_clean_area(cli1, cli2);
130
131 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
132 SEC_RIGHTS_FILE_ALL,
133 FILE_ATTRIBUTE_NORMAL,
134 NTCREATEX_SHARE_ACCESS_DELETE, NTCREATEX_DISP_OVERWRITE_IF,
135 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
136
137 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
138 fname, smbcli_errstr(cli1->tree)));
139
140 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
141 talloc_asprintf(tctx, "close failed (%s)", smbcli_errstr(cli1->tree)));
142
143 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
144 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail)",
145 fname));
146
147 return true;
148 }
149
150 /* Test 2 - this should delete the file on close. */
151 static bool deltest2(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
152 {
153 int fnum1 = -1;
154
155 del_clean_area(cli1, cli2);
156
157 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
158 SEC_RIGHTS_FILE_ALL,
159 FILE_ATTRIBUTE_NORMAL, NTCREATEX_SHARE_ACCESS_NONE,
160 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
161
162 torture_assert(tctx, fnum1 != -1,
163 talloc_asprintf(tctx, "open of %s failed (%s)",
164 fname, smbcli_errstr(cli1->tree)));
165
166 torture_assert_ntstatus_ok(tctx, smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
167 talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
168 smbcli_errstr(cli1->tree)));
169
170 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
171 talloc_asprintf(tctx, "close failed (%s)",
172 smbcli_errstr(cli1->tree)));
173
174 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
175 if (fnum1 != -1) {
176 printf("(%s) open of %s succeeded should have been deleted on close !\n",
177 __location__, fname);
178 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
179 printf("(%s) close failed (%s)\n",
180 __location__, smbcli_errstr(cli1->tree));
181 return false;
182 }
183 smbcli_unlink(cli1->tree, fname);
184 }
185 return true;
186 }
187
188 /* Test 3 - ... */
189 static bool deltest3(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
190 {
191 int fnum1 = -1;
192 int fnum2 = -1;
193
194 del_clean_area(cli1, cli2);
195
196 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
197 SEC_RIGHTS_FILE_ALL,
198 FILE_ATTRIBUTE_NORMAL,
199 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
200 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
201
202 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
203 fname, smbcli_errstr(cli1->tree)));
204
205 /* This should fail with a sharing violation - open for delete is only compatible
206 with SHARE_DELETE. */
207
208 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
209 SEC_RIGHTS_FILE_READ,
210 FILE_ATTRIBUTE_NORMAL,
211 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
212 NTCREATEX_DISP_OPEN, 0, 0);
213
214 torture_assert(tctx, fnum2 == -1,
215 talloc_asprintf(tctx, "open - 2 of %s succeeded - should have failed.",
216 fname));
217
218 /* This should succeed. */
219
220 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
221 SEC_RIGHTS_FILE_READ,
222 FILE_ATTRIBUTE_NORMAL,
223 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
224 NTCREATEX_DISP_OPEN, 0, 0);
225
226 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
227 fname, smbcli_errstr(cli1->tree)));
228
229 torture_assert_ntstatus_ok(tctx,
230 smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
231 talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
232 smbcli_errstr(cli1->tree)));
233
234 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
235 talloc_asprintf(tctx, "close 1 failed (%s)",
236 smbcli_errstr(cli1->tree)));
237
238 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum2),
239 talloc_asprintf(tctx, "close 2 failed (%s)",
240 smbcli_errstr(cli1->tree)));
241
242 /* This should fail - file should no longer be there. */
243
244 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
245 if (fnum1 != -1) {
246 printf("(%s) open of %s succeeded should have been deleted on close !\n",
247 __location__, fname);
248 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
249 printf("(%s) close failed (%s)\n",
250 __location__, smbcli_errstr(cli1->tree));
251 }
252 smbcli_unlink(cli1->tree, fname);
253 return false;
254 }
255 return true;
256 }
257
258 /* Test 4 ... */
259 static bool deltest4(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
260 {
261 int fnum1 = -1;
262 int fnum2 = -1;
263 bool correct = true;
264
265 del_clean_area(cli1, cli2);
266
267 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
268 SEC_FILE_READ_DATA |
269 SEC_FILE_WRITE_DATA |
270 SEC_STD_DELETE,
271 FILE_ATTRIBUTE_NORMAL,
272 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
273 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
274
275 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
276 fname, smbcli_errstr(cli1->tree)));
277
278 /* This should succeed. */
279 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
280 SEC_RIGHTS_FILE_READ,
281 FILE_ATTRIBUTE_NORMAL,
282 NTCREATEX_SHARE_ACCESS_READ |
283 NTCREATEX_SHARE_ACCESS_WRITE |
284 NTCREATEX_SHARE_ACCESS_DELETE,
285 NTCREATEX_DISP_OPEN, 0, 0);
286 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
287 fname, smbcli_errstr(cli1->tree)));
288
289 torture_assert_ntstatus_ok(tctx,
290 smbcli_close(cli1->tree, fnum2),
291 talloc_asprintf(tctx, "close - 1 failed (%s)",
292 smbcli_errstr(cli1->tree)));
293
294 torture_assert_ntstatus_ok(tctx,
295 smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
296 talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
297 smbcli_errstr(cli1->tree)));
298
299 /* This should fail - no more opens once delete on close set. */
300 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
301 SEC_RIGHTS_FILE_READ,
302 FILE_ATTRIBUTE_NORMAL,
303 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
304 NTCREATEX_DISP_OPEN, 0, 0);
305 torture_assert(tctx, fnum2 == -1,
306 talloc_asprintf(tctx, "open - 3 of %s succeeded ! Should have failed.",
307 fname ));
308
309 CHECK_STATUS(cli1, NT_STATUS_DELETE_PENDING);
310
311 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
312 talloc_asprintf(tctx, "close - 2 failed (%s)",
313 smbcli_errstr(cli1->tree)));
314
315 return correct;
316 }
317
318 /* Test 5 ... */
319 static bool deltest5(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
320 {
321 int fnum1 = -1;
322
323 del_clean_area(cli1, cli2);
324
325 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
326 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
327 fname, smbcli_errstr(cli1->tree)));
328
329 /* This should fail - only allowed on NT opens with DELETE access. */
330
331 torture_assert(tctx, !NT_STATUS_IS_OK(smbcli_nt_delete_on_close(cli1->tree, fnum1, true)),
332 "setting delete_on_close on OpenX file succeeded - should fail !");
333
334 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
335 talloc_asprintf(tctx, "close - 2 failed (%s)", smbcli_errstr(cli1->tree)));
336
337 return true;
338 }
339
340 /* Test 6 ... */
341 static bool deltest6(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
342 {
343 int fnum1 = -1;
344
345 del_clean_area(cli1, cli2);
346
347 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
348 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
349 FILE_ATTRIBUTE_NORMAL,
350 NTCREATEX_SHARE_ACCESS_READ |
351 NTCREATEX_SHARE_ACCESS_WRITE |
352 NTCREATEX_SHARE_ACCESS_DELETE,
353 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
354
355 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
356 fname, smbcli_errstr(cli1->tree)));
357
358 /* This should fail - only allowed on NT opens with DELETE access. */
359
360 torture_assert(tctx,
361 !NT_STATUS_IS_OK(smbcli_nt_delete_on_close(cli1->tree, fnum1, true)),
362 "setting delete_on_close on file with no delete access succeeded - should fail !");
363
364 torture_assert_ntstatus_ok(tctx,
365 smbcli_close(cli1->tree, fnum1),
366 talloc_asprintf(tctx,
367 "close - 2 failed (%s)",
368 smbcli_errstr(cli1->tree)));
369
370 return true;
371 }
372
373 /* Test 7 ... */
374 static bool deltest7(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
375 {
376 int fnum1 = -1;
377 bool correct = true;
378
379 del_clean_area(cli1, cli2);
380
381 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
382 SEC_FILE_READ_DATA |
383 SEC_FILE_WRITE_DATA |
384 SEC_STD_DELETE,
385 FILE_ATTRIBUTE_NORMAL, 0,
386 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
387
388 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
389 fname, smbcli_errstr(cli1->tree)));
390
391 torture_assert_ntstatus_ok(tctx, smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
392 "setting delete_on_close on file failed !");
393
394 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, true, __location__);
395
396 torture_assert_ntstatus_ok(tctx,
397 smbcli_nt_delete_on_close(cli1->tree, fnum1, false),
398 "unsetting delete_on_close on file failed !");
399
400 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
401
402 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
403 talloc_asprintf(tctx, "close - 2 failed (%s)", smbcli_errstr(cli1->tree)));
404
405 /* This next open should succeed - we reset the flag. */
406
407 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
408 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
409 fname, smbcli_errstr(cli1->tree)));
410
411 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
412 talloc_asprintf(tctx, "close - 2 failed (%s)",
413 smbcli_errstr(cli1->tree)));
414
415 return correct;
416 }
417
418 /* Test 8 ... */
419 static bool deltest8(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
420 {
421 int fnum1 = -1;
422 int fnum2 = -1;
423 bool correct = true;
424
425 del_clean_area(cli1, cli2);
426
427 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
428 SEC_FILE_READ_DATA|
429 SEC_FILE_WRITE_DATA|
430 SEC_STD_DELETE,
431 FILE_ATTRIBUTE_NORMAL,
432 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
433 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
434
435 torture_assert(tctx, fnum1 != -1,
436 talloc_asprintf(tctx, "open of %s failed (%s)",
437 fname, smbcli_errstr(cli1->tree)));
438
439 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
440 SEC_FILE_READ_DATA|
441 SEC_FILE_WRITE_DATA|
442 SEC_STD_DELETE,
443 FILE_ATTRIBUTE_NORMAL,
444 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
445 NTCREATEX_DISP_OPEN, 0, 0);
446
447 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
448 fname, smbcli_errstr(cli1->tree)));
449
450 torture_assert_ntstatus_ok(tctx,
451 smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
452 "setting delete_on_close on file failed !");
453
454 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, true, __location__);
455 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, true, __location__);
456
457 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
458 talloc_asprintf(tctx, "close - 1 failed (%s)",
459 smbcli_errstr(cli1->tree)));
460
461 correct &= check_delete_on_close(tctx, cli1, -1, fname, true, __location__);
462 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, true, __location__);
463
464 torture_assert_ntstatus_ok(tctx, smbcli_close(cli2->tree, fnum2),
465 talloc_asprintf(tctx, "close - 2 failed (%s)", smbcli_errstr(cli2->tree)));
466
467 /* This should fail.. */
468 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
469 torture_assert(tctx, fnum1 == -1,
470 talloc_asprintf(tctx, "open of %s succeeded should have been deleted on close !\n", fname));
471
472 return correct;
473 }
474
475 /* Test 9 ... */
476 static bool deltest9(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
477 {
478 int fnum1 = -1;
479
480 del_clean_area(cli1, cli2);
481
482 /* This should fail - we need to set DELETE_ACCESS. */
483 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
484 SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA,
485 FILE_ATTRIBUTE_NORMAL,
486 NTCREATEX_SHARE_ACCESS_NONE,
487 NTCREATEX_DISP_OVERWRITE_IF,
488 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
489
490 torture_assert(tctx, fnum1 == -1,
491 talloc_asprintf(tctx, "open of %s succeeded should have failed!",
492 fname));
493
494 return true;
495 }
496
497 /* Test 10 ... */
498 static bool deltest10(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
499 {
500 int fnum1 = -1;
501
502 del_clean_area(cli1, cli2);
503
504 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
505 SEC_FILE_READ_DATA|
506 SEC_FILE_WRITE_DATA|
507 SEC_STD_DELETE,
508 FILE_ATTRIBUTE_NORMAL,
509 NTCREATEX_SHARE_ACCESS_NONE,
510 NTCREATEX_DISP_OVERWRITE_IF,
511 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
512 torture_assert(tctx, fnum1 != -1,
513 talloc_asprintf(tctx, "open of %s failed (%s)",
514 fname, smbcli_errstr(cli1->tree)));
515
516 /* This should delete the file. */
517 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
518 talloc_asprintf(tctx, "close failed (%s)",
519 smbcli_errstr(cli1->tree)));
520
521 /* This should fail.. */
522 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
523 torture_assert(tctx, fnum1 == -1,
524 talloc_asprintf(tctx, "open of %s succeeded should have been deleted on close !",
525 fname));
526 return true;
527 }
528
529 /* Test 11 ... */
530 static bool deltest11(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
531 {
532 int fnum1 = -1;
533 NTSTATUS status;
534
535 del_clean_area(cli1, cli2);
536
537 /* test 11 - does having read only attribute still allow delete on close. */
538
539 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
540 SEC_RIGHTS_FILE_ALL,
541 FILE_ATTRIBUTE_READONLY,
542 NTCREATEX_SHARE_ACCESS_NONE,
543 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
544
545 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
546 fname, smbcli_errstr(cli1->tree)));
547
548 status = smbcli_nt_delete_on_close(cli1->tree, fnum1, true);
549
550 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_CANNOT_DELETE,
551 talloc_asprintf(tctx, "setting delete_on_close should fail with NT_STATUS_CANNOT_DELETE. Got %s instead)", smbcli_errstr(cli1->tree)));
552
553 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
554 talloc_asprintf(tctx, "close failed (%s)",
555 smbcli_errstr(cli1->tree)));
556
557 return true;
558 }
559
560 /* Test 12 ... */
561 static bool deltest12(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
562 {
563 int fnum1 = -1;
564 NTSTATUS status;
565
566 del_clean_area(cli1, cli2);
567
568 /* test 12 - does having read only attribute still allow delete on
569 * close at time of open. */
570
571 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
572 SEC_RIGHTS_FILE_ALL,
573 FILE_ATTRIBUTE_READONLY,
574 NTCREATEX_SHARE_ACCESS_DELETE,
575 NTCREATEX_DISP_OVERWRITE_IF,
576 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
577
578 torture_assert(tctx, fnum1 == -1,
579 talloc_asprintf(tctx, "open of %s succeeded. Should fail with "
580 "NT_STATUS_CANNOT_DELETE.\n", fname));
581
582 status = smbcli_nt_error(cli1->tree);
583 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_CANNOT_DELETE,
584 talloc_asprintf(tctx, "setting delete_on_close on open should "
585 "fail with NT_STATUS_CANNOT_DELETE. Got %s "
586 "instead)",
587 smbcli_errstr(cli1->tree)));
588
589 return true;
590 }
591
592 /* Test 13 ... */
593 static bool deltest13(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
594 {
595 int fnum1 = -1;
596 int fnum2 = -1;
597 bool correct = true;
598
599 del_clean_area(cli1, cli2);
600
601 /* Test 13: Does resetting the delete on close flag affect a second
602 * fd? */
603
604 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
605 SEC_FILE_READ_DATA|
606 SEC_FILE_WRITE_DATA|
607 SEC_STD_DELETE,
608 FILE_ATTRIBUTE_NORMAL,
609 NTCREATEX_SHARE_ACCESS_READ|
610 NTCREATEX_SHARE_ACCESS_WRITE|
611 NTCREATEX_SHARE_ACCESS_DELETE,
612 NTCREATEX_DISP_OVERWRITE_IF,
613 0, 0);
614
615 torture_assert(tctx, fnum1 != -1,
616 talloc_asprintf(tctx, "open of %s failed (%s)",
617 fname, smbcli_errstr(cli1->tree)));
618
619 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
620 SEC_FILE_READ_DATA|
621 SEC_FILE_WRITE_DATA|
622 SEC_STD_DELETE,
623 FILE_ATTRIBUTE_NORMAL,
624 NTCREATEX_SHARE_ACCESS_READ|
625 NTCREATEX_SHARE_ACCESS_WRITE|
626 NTCREATEX_SHARE_ACCESS_DELETE,
627 NTCREATEX_DISP_OPEN, 0, 0);
628
629 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx,
630 "open of %s failed (%s)",
631 fname, smbcli_errstr(cli2->tree)));
632
633 torture_assert_ntstatus_ok(tctx,
634 smbcli_nt_delete_on_close(cli1->tree, fnum1,
635 true),
636 "setting delete_on_close on file failed !");
637
638 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, true, __location__);
639 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, true, __location__);
640
641 torture_assert_ntstatus_ok(tctx, smbcli_nt_delete_on_close(cli2->tree, fnum2,
642 false),
643 "setting delete_on_close on file failed !");
644
645 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
646 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
647
648 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
649 talloc_asprintf(tctx, "close - 1 failed (%s)",
650 smbcli_errstr(cli1->tree)));
651
652 torture_assert_ntstatus_ok(tctx, smbcli_close(cli2->tree, fnum2),
653 talloc_asprintf(tctx, "close - 2 failed (%s)",
654 smbcli_errstr(cli2->tree)));
655
656 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
657
658 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed!",
659 fname));
660
661 smbcli_close(cli1->tree, fnum1);
662
663 return correct;
664 }
665
666 /* Test 14 ... */
667 static bool deltest14(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
668 {
669 int dnum1 = -1;
670 bool correct = true;
671
672 del_clean_area(cli1, cli2);
673
674 /* Test 14 -- directory */
675
676 dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
677 SEC_FILE_READ_DATA|
678 SEC_FILE_WRITE_DATA|
679 SEC_STD_DELETE,
680 FILE_ATTRIBUTE_DIRECTORY,
681 NTCREATEX_SHARE_ACCESS_READ|
682 NTCREATEX_SHARE_ACCESS_WRITE|
683 NTCREATEX_SHARE_ACCESS_DELETE,
684 NTCREATEX_DISP_CREATE, 0, 0);
685 torture_assert(tctx, dnum1 != -1, talloc_asprintf(tctx, "open of %s failed: %s!",
686 dname, smbcli_errstr(cli1->tree)));
687
688 correct &= check_delete_on_close(tctx, cli1, dnum1, dname, false, __location__);
689 torture_assert_ntstatus_ok(tctx, smbcli_nt_delete_on_close(cli1->tree, dnum1, true),
690 "setting delete_on_close on file failed !");
691 correct &= check_delete_on_close(tctx, cli1, dnum1, dname, true, __location__);
692 smbcli_close(cli1->tree, dnum1);
693
694 /* Now it should be gone... */
695
696 dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
697 SEC_FILE_READ_DATA|
698 SEC_FILE_WRITE_DATA|
699 SEC_STD_DELETE,
700 FILE_ATTRIBUTE_DIRECTORY,
701 NTCREATEX_SHARE_ACCESS_READ|
702 NTCREATEX_SHARE_ACCESS_WRITE|
703 NTCREATEX_SHARE_ACCESS_DELETE,
704 NTCREATEX_DISP_OPEN, 0, 0);
705 torture_assert(tctx, dnum1 == -1, "setting delete_on_close on file succeeded !");
706
707 return correct;
708 }
709
710 /* Test 15 ... */
711 static bool deltest15(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
712 {
713 int fnum1 = -1;
714 bool correct = true;
715 int fnum2 = -1;
716 NTSTATUS status;
717
718 del_clean_area(cli1, cli2);
719
720 /* Test 15: delete on close under rename */
721
722 smbcli_setatr(cli1->tree, fname, 0, 0);
723 smbcli_unlink(cli1->tree, fname);
724 smbcli_unlink(cli1->tree, fname_new);
725
726 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
727 SEC_FILE_READ_DATA,
728 FILE_ATTRIBUTE_NORMAL,
729 NTCREATEX_SHARE_ACCESS_READ|
730 NTCREATEX_SHARE_ACCESS_WRITE|
731 NTCREATEX_SHARE_ACCESS_DELETE,
732 NTCREATEX_DISP_OVERWRITE_IF,
733 0, 0);
734
735 torture_assert(tctx, fnum1 != -1,
736 talloc_asprintf(tctx, "open - 1 of %s failed (%s)", fname, smbcli_errstr(cli1->tree)));
737
738 status = smbcli_rename(cli2->tree, fname, fname_new);
739
740 torture_assert_ntstatus_ok(tctx, status, "renaming failed!");
741
742 fnum2 = smbcli_nt_create_full(cli2->tree, fname_new, 0,
743 SEC_GENERIC_ALL,
744 FILE_ATTRIBUTE_NORMAL,
745 NTCREATEX_SHARE_ACCESS_READ|
746 NTCREATEX_SHARE_ACCESS_WRITE|
747 NTCREATEX_SHARE_ACCESS_DELETE,
748 NTCREATEX_DISP_OVERWRITE_IF,
749 0, 0);
750
751 torture_assert(tctx, fnum2 != -1,
752 talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
753 fname_new, smbcli_errstr(cli1->tree)));
754
755 status = smbcli_nt_delete_on_close(cli2->tree, fnum2, true);
756
757 torture_assert_ntstatus_ok(tctx, status,
758 "setting delete_on_close on file failed !");
759
760 smbcli_close(cli2->tree, fnum2);
761
762 /* The file should be around under the new name, there's a second
763 * handle open */
764
765 correct &= check_delete_on_close(tctx, cli1, fnum1, fname_new, true, __location__);
766
767 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
768 SEC_GENERIC_ALL,
769 FILE_ATTRIBUTE_NORMAL,
770 NTCREATEX_SHARE_ACCESS_READ|
771 NTCREATEX_SHARE_ACCESS_WRITE|
772 NTCREATEX_SHARE_ACCESS_DELETE,
773 NTCREATEX_DISP_OVERWRITE_IF,
774 0, 0);
775
776 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
777 fname, smbcli_errstr(cli1->tree)));
778
779 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
780
781 smbcli_close(cli2->tree, fnum2);
782 smbcli_close(cli1->tree, fnum1);
783
784 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
785 SEC_FILE_READ_EA,
786 FILE_ATTRIBUTE_NORMAL,
787 NTCREATEX_SHARE_ACCESS_READ|
788 NTCREATEX_SHARE_ACCESS_WRITE|
789 NTCREATEX_SHARE_ACCESS_DELETE,
790 NTCREATEX_DISP_OPEN,
791 0, 0);
792
793 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
794 fname, smbcli_errstr(cli1->tree)));
795
796 smbcli_close(cli1->tree, fnum1);
797
798 fnum1 = smbcli_nt_create_full(cli1->tree, fname_new, 0,
799 SEC_FILE_READ_EA,
800 FILE_ATTRIBUTE_NORMAL,
801 NTCREATEX_SHARE_ACCESS_READ|
802 NTCREATEX_SHARE_ACCESS_WRITE|
803 NTCREATEX_SHARE_ACCESS_DELETE,
804 NTCREATEX_DISP_OPEN,
805 0, 0);
806
807 torture_assert(tctx, fnum1 == -1,
808 "smbcli_open succeeded, should have "
809 "failed");
810
811 return correct;
812 }
813
814 /* Test 16 ... */
815 static bool deltest16(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
816 {
817 int fnum1 = -1;
818 int fnum2 = -1;
819 bool correct = true;
820
821 del_clean_area(cli1, cli2);
822
823 /* Test 16. */
824
825 /* Ensure the file doesn't already exist. */
826 smbcli_close(cli1->tree, fnum1);
827 smbcli_close(cli1->tree, fnum2);
828 smbcli_setatr(cli1->tree, fname, 0, 0);
829 smbcli_unlink(cli1->tree, fname);
830
831 /* Firstly create with all access, but delete on close. */
832 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
833 SEC_RIGHTS_FILE_ALL,
834 FILE_ATTRIBUTE_NORMAL,
835 NTCREATEX_SHARE_ACCESS_READ|
836 NTCREATEX_SHARE_ACCESS_WRITE|
837 NTCREATEX_SHARE_ACCESS_DELETE,
838 NTCREATEX_DISP_CREATE,
839 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
840
841 torture_assert (tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)", fname, smbcli_errstr(cli1->tree)));
842
843 /* The delete on close bit is *not* reported as being set. */
844 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
845
846 /* The delete on close bit is *not* reported as being set. */
847 correct &= check_delete_on_close(tctx, cli1, -1, fname, false, __location__);
848 correct &= check_delete_on_close(tctx, cli2, -1, fname, false, __location__);
849
850 /* Now try opening again for read-only. */
851 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
852 SEC_RIGHTS_FILE_READ,
853 FILE_ATTRIBUTE_NORMAL,
854 NTCREATEX_SHARE_ACCESS_READ|
855 NTCREATEX_SHARE_ACCESS_WRITE|
856 NTCREATEX_SHARE_ACCESS_DELETE,
857 NTCREATEX_DISP_OPEN,
858 0, 0);
859
860 /* Should work. */
861 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
862 fname, smbcli_errstr(cli1->tree)));
863
864 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
865 correct &= check_delete_on_close(tctx, cli1, -1, fname, false, __location__);
866 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
867 correct &= check_delete_on_close(tctx, cli2, -1, fname, false, __location__);
868
869 smbcli_close(cli1->tree, fnum1);
870
871 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, true, __location__);
872 correct &= check_delete_on_close(tctx, cli2, -1, fname, true, __location__);
873
874 smbcli_close(cli2->tree, fnum2);
875
876 /* And the file should be deleted ! */
877 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
878 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail)",
879 fname));
880
881 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
882
883 return correct;
884 }
885
886 /* Test 16 ... */
887 static bool deltest16a(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
888 {
889 int fnum1 = -1;
890 int fnum2 = -1;
891 bool correct = true;
892
893 del_clean_area(cli1, cli2);
894
895 /* Test 16. */
896
897 /* Ensure the file doesn't already exist. */
898 smbcli_close(cli1->tree, fnum1);
899 smbcli_close(cli1->tree, fnum2);
900 smbcli_setatr(cli1->tree, fname, 0, 0);
901 smbcli_unlink(cli1->tree, fname);
902
903 /* Firstly open and create with all access */
904 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
905 SEC_RIGHTS_FILE_ALL,
906 FILE_ATTRIBUTE_NORMAL,
907 NTCREATEX_SHARE_ACCESS_READ|
908 NTCREATEX_SHARE_ACCESS_WRITE|
909 NTCREATEX_SHARE_ACCESS_DELETE,
910 NTCREATEX_DISP_CREATE,
911 0, 0);
912 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
913 fname, smbcli_errstr(cli1->tree)));
914
915 /* And close - just to create the file. */
916 smbcli_close(cli1->tree, fnum1);
917
918 /* Firstly create with all access, but delete on close. */
919 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
920 SEC_RIGHTS_FILE_ALL,
921 FILE_ATTRIBUTE_NORMAL,
922 NTCREATEX_SHARE_ACCESS_READ|
923 NTCREATEX_SHARE_ACCESS_WRITE|
924 NTCREATEX_SHARE_ACCESS_DELETE,
925 NTCREATEX_DISP_OPEN,
926 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
927
928 torture_assert (tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)", fname, smbcli_errstr(cli1->tree)));
929
930 /* The delete on close bit is *not* reported as being set. */
931 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
932
933 /* The delete on close bit is *not* reported as being set. */
934 correct &= check_delete_on_close(tctx, cli1, -1, fname, false, __location__);
935 correct &= check_delete_on_close(tctx, cli2, -1, fname, false, __location__);
936
937 /* Now try opening again for read-only. */
938 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
939 SEC_RIGHTS_FILE_READ,
940 FILE_ATTRIBUTE_NORMAL,
941 NTCREATEX_SHARE_ACCESS_READ|
942 NTCREATEX_SHARE_ACCESS_WRITE|
943 NTCREATEX_SHARE_ACCESS_DELETE,
944 NTCREATEX_DISP_OPEN,
945 0, 0);
946
947 /* Should work. */
948 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
949 fname, smbcli_errstr(cli1->tree)));
950
951 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
952 correct &= check_delete_on_close(tctx, cli1, -1, fname, false, __location__);
953 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
954 correct &= check_delete_on_close(tctx, cli2, -1, fname, false, __location__);
955
956 smbcli_close(cli1->tree, fnum1);
957
958 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
959 correct &= check_delete_on_close(tctx, cli2, -1, fname, false, __location__);
960
961 smbcli_close(cli2->tree, fnum2);
962
963 /* And the file should be deleted ! */
964 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
965 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
966 fname, smbcli_errstr(cli1->tree)));
967
968 smbcli_close(cli1->tree, fnum1);
969 smbcli_setatr(cli1->tree, fname, 0, 0);
970 smbcli_unlink(cli1->tree, fname);
971
972 return correct;
973 }
974
975 /* Test 17 ... */
976 static bool deltest17(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
977 {
978 int fnum1 = -1;
979 int fnum2 = -1;
980 bool correct = true;
981
982 del_clean_area(cli1, cli2);
983
984 /* Test 17. */
985
986 /* Ensure the file doesn't already exist. */
987 smbcli_close(cli1->tree, fnum1);
988 smbcli_close(cli1->tree, fnum2);
989 smbcli_setatr(cli1->tree, fname, 0, 0);
990 smbcli_unlink(cli1->tree, fname);
991
992 /* Firstly open and create with all access */
993 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
994 SEC_RIGHTS_FILE_ALL,
995 FILE_ATTRIBUTE_NORMAL,
996 NTCREATEX_SHARE_ACCESS_READ|
997 NTCREATEX_SHARE_ACCESS_WRITE|
998 NTCREATEX_SHARE_ACCESS_DELETE,
999 NTCREATEX_DISP_CREATE,
1000 0, 0);
1001 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1002 fname, smbcli_errstr(cli1->tree)));
1003
1004 /* And close - just to create the file. */
1005 smbcli_close(cli1->tree, fnum1);
1006
1007 /* Next open with all access, but add delete on close. */
1008 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1009 SEC_RIGHTS_FILE_ALL,
1010 FILE_ATTRIBUTE_NORMAL,
1011 NTCREATEX_SHARE_ACCESS_READ|
1012 NTCREATEX_SHARE_ACCESS_WRITE|
1013 NTCREATEX_SHARE_ACCESS_DELETE,
1014 NTCREATEX_DISP_OPEN,
1015 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1016
1017 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1018 fname, smbcli_errstr(cli1->tree)));
1019
1020 /* The delete on close bit is *not* reported as being set. */
1021 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1022
1023 /* Now try opening again for read-only. */
1024 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
1025 SEC_RIGHTS_FILE_READ|
1026 SEC_STD_DELETE,
1027 FILE_ATTRIBUTE_NORMAL,
1028 NTCREATEX_SHARE_ACCESS_READ|
1029 NTCREATEX_SHARE_ACCESS_WRITE|
1030 NTCREATEX_SHARE_ACCESS_DELETE,
1031 NTCREATEX_DISP_OPEN,
1032 0, 0);
1033
1034 /* Should work. */
1035 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1036 fname, smbcli_errstr(cli1->tree)));
1037
1038 /* still not reported as being set on either */
1039 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1040 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1041
1042 smbcli_close(cli1->tree, fnum1);
1043
1044 /* After the first close, the files has the delete on close bit set. */
1045 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, true, __location__);
1046
1047 smbcli_close(cli1->tree, fnum2);
1048
1049 /* Make sure the file has been deleted */
1050 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1051 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s failed (should succeed) - %s",
1052 fname, smbcli_errstr(cli1->tree)));
1053
1054 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1055
1056 return correct;
1057 }
1058
1059 /* Test 17a - like 17, but the delete on close handle is closed last */
1060 static bool deltest17a(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1061 {
1062 int fnum1 = -1;
1063 int fnum2 = -1;
1064 bool correct = true;
1065
1066 del_clean_area(cli1, cli2);
1067
1068 /* Ensure the file doesn't already exist. */
1069 smbcli_close(cli1->tree, fnum1);
1070 smbcli_close(cli1->tree, fnum2);
1071 smbcli_setatr(cli1->tree, fname, 0, 0);
1072 smbcli_unlink(cli1->tree, fname);
1073
1074 /* Firstly open and create with all access */
1075 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1076 SEC_RIGHTS_FILE_ALL,
1077 FILE_ATTRIBUTE_NORMAL,
1078 NTCREATEX_SHARE_ACCESS_READ|
1079 NTCREATEX_SHARE_ACCESS_WRITE|
1080 NTCREATEX_SHARE_ACCESS_DELETE,
1081 NTCREATEX_DISP_CREATE,
1082 0, 0);
1083 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1084 fname, smbcli_errstr(cli1->tree)));
1085
1086 /* And close - just to create the file. */
1087 smbcli_close(cli1->tree, fnum1);
1088
1089 /* Next open with all access, but add delete on close. */
1090 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1091 SEC_RIGHTS_FILE_ALL,
1092 FILE_ATTRIBUTE_NORMAL,
1093 NTCREATEX_SHARE_ACCESS_READ|
1094 NTCREATEX_SHARE_ACCESS_WRITE|
1095 NTCREATEX_SHARE_ACCESS_DELETE,
1096 NTCREATEX_DISP_OPEN,
1097 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1098
1099 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1100 fname, smbcli_errstr(cli1->tree)));
1101
1102 /* The delete on close bit is *not* reported as being set. */
1103 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1104
1105 /* Now try opening again for read-only. */
1106 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
1107 SEC_RIGHTS_FILE_READ|
1108 SEC_STD_DELETE,
1109 FILE_ATTRIBUTE_NORMAL,
1110 NTCREATEX_SHARE_ACCESS_READ|
1111 NTCREATEX_SHARE_ACCESS_WRITE|
1112 NTCREATEX_SHARE_ACCESS_DELETE,
1113 NTCREATEX_DISP_OPEN,
1114 0, 0);
1115
1116 /* Should work. */
1117 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1118 fname, smbcli_errstr(cli1->tree)));
1119
1120 /* still not reported as being set on either */
1121 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1122 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1123
1124 smbcli_close(cli1->tree, fnum2);
1125
1126 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1127
1128 smbcli_close(cli1->tree, fnum1);
1129
1130 /*
1131 * The file is still there:
1132 * The second open seems to have removed the initial
1133 * delete on close flag from the first handle
1134 */
1135 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1136 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 3 of %s failed (%s)",
1137 fname, smbcli_errstr(cli1->tree)));
1138
1139 smbcli_close(cli1->tree, fnum1);
1140 smbcli_setatr(cli1->tree, fname, 0, 0);
1141 smbcli_unlink(cli1->tree, fname);
1142
1143 return correct;
1144 }
1145
1146 /* Test 17b - like 17a, but the initial delete on close is set on the second handle */
1147 static bool deltest17b(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1148 {
1149 int fnum1 = -1;
1150 int fnum2 = -1;
1151 bool correct = true;
1152
1153 del_clean_area(cli1, cli2);
1154
1155 /* Ensure the file doesn't already exist. */
1156 smbcli_close(cli1->tree, fnum1);
1157 smbcli_close(cli1->tree, fnum2);
1158 smbcli_setatr(cli1->tree, fname, 0, 0);
1159 smbcli_unlink(cli1->tree, fname);
1160
1161 /* Firstly open and create with all access */
1162 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1163 SEC_RIGHTS_FILE_ALL,
1164 FILE_ATTRIBUTE_NORMAL,
1165 NTCREATEX_SHARE_ACCESS_READ|
1166 NTCREATEX_SHARE_ACCESS_WRITE|
1167 NTCREATEX_SHARE_ACCESS_DELETE,
1168 NTCREATEX_DISP_CREATE,
1169 0, 0);
1170 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1171 fname, smbcli_errstr(cli1->tree)));
1172
1173 /* And close - just to create the file. */
1174 smbcli_close(cli1->tree, fnum1);
1175
1176 /* Next open with all access, but add delete on close. */
1177 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1178 SEC_RIGHTS_FILE_ALL,
1179 FILE_ATTRIBUTE_NORMAL,
1180 NTCREATEX_SHARE_ACCESS_READ|
1181 NTCREATEX_SHARE_ACCESS_WRITE|
1182 NTCREATEX_SHARE_ACCESS_DELETE,
1183 NTCREATEX_DISP_OPEN,
1184 0, 0);
1185
1186 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1187 fname, smbcli_errstr(cli1->tree)));
1188
1189 /* The delete on close bit is *not* reported as being set. */
1190 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1191
1192 /* Now try opening again for read-only. */
1193 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
1194 SEC_RIGHTS_FILE_READ|
1195 SEC_STD_DELETE,
1196 FILE_ATTRIBUTE_NORMAL,
1197 NTCREATEX_SHARE_ACCESS_READ|
1198 NTCREATEX_SHARE_ACCESS_WRITE|
1199 NTCREATEX_SHARE_ACCESS_DELETE,
1200 NTCREATEX_DISP_OPEN,
1201 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1202
1203 /* Should work. */
1204 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1205 fname, smbcli_errstr(cli1->tree)));
1206
1207 /* still not reported as being set on either */
1208 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1209 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1210
1211 smbcli_close(cli1->tree, fnum1);
1212
1213 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1214
1215 smbcli_close(cli1->tree, fnum2);
1216
1217 /* Make sure the file has been deleted */
1218 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1219 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open - 3 of %s succeeded (should fail)",
1220 fname));
1221
1222 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1223
1224 return correct;
1225 }
1226
1227 /* Test 17c - like 17, but the initial delete on close is set on the second handle */
1228 static bool deltest17c(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1229 {
1230 int fnum1 = -1;
1231 int fnum2 = -1;
1232 bool correct = true;
1233
1234 del_clean_area(cli1, cli2);
1235
1236 /* Ensure the file doesn't already exist. */
1237 smbcli_close(cli1->tree, fnum1);
1238 smbcli_close(cli1->tree, fnum2);
1239 smbcli_setatr(cli1->tree, fname, 0, 0);
1240 smbcli_unlink(cli1->tree, fname);
1241
1242 /* Firstly open and create with all access */
1243 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1244 SEC_RIGHTS_FILE_ALL,
1245 FILE_ATTRIBUTE_NORMAL,
1246 NTCREATEX_SHARE_ACCESS_READ|
1247 NTCREATEX_SHARE_ACCESS_WRITE|
1248 NTCREATEX_SHARE_ACCESS_DELETE,
1249 NTCREATEX_DISP_CREATE,
1250 0, 0);
1251 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1252 fname, smbcli_errstr(cli1->tree)));
1253
1254 /* And close - just to create the file. */
1255 smbcli_close(cli1->tree, fnum1);
1256
1257 /* Next open with all access, but add delete on close. */
1258 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1259 SEC_RIGHTS_FILE_ALL,
1260 FILE_ATTRIBUTE_NORMAL,
1261 NTCREATEX_SHARE_ACCESS_READ|
1262 NTCREATEX_SHARE_ACCESS_WRITE|
1263 NTCREATEX_SHARE_ACCESS_DELETE,
1264 NTCREATEX_DISP_OPEN,
1265 0, 0);
1266
1267 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1268 fname, smbcli_errstr(cli1->tree)));
1269
1270 /* The delete on close bit is *not* reported as being set. */
1271 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1272
1273 /* Now try opening again for read-only. */
1274 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
1275 SEC_RIGHTS_FILE_READ|
1276 SEC_STD_DELETE,
1277 FILE_ATTRIBUTE_NORMAL,
1278 NTCREATEX_SHARE_ACCESS_READ|
1279 NTCREATEX_SHARE_ACCESS_WRITE|
1280 NTCREATEX_SHARE_ACCESS_DELETE,
1281 NTCREATEX_DISP_OPEN,
1282 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1283
1284 /* Should work. */
1285 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1286 fname, smbcli_errstr(cli1->tree)));
1287
1288 /* still not reported as being set on either */
1289 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1290 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1291
1292 smbcli_close(cli1->tree, fnum2);
1293
1294 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, true, __location__);
1295
1296 fnum2 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1297 torture_assert(tctx, fnum2 == -1, talloc_asprintf(tctx, "open - 3 of %s succeeded (should fail)",
1298 fname));
1299
1300 CHECK_STATUS(cli1, NT_STATUS_DELETE_PENDING);
1301
1302 smbcli_close(cli1->tree, fnum1);
1303
1304 /* Make sure the file has been deleted */
1305 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1306 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open - 4 of %s succeeded (should fail)",
1307 fname));
1308
1309 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1310
1311 return correct;
1312 }
1313
1314 /* Test 17d - like 17a, but the first delete-on-close opener creates the file */
1315 static bool deltest17d(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1316 {
1317 int fnum1 = -1;
1318 int fnum2 = -1;
1319 bool correct = true;
1320
1321 del_clean_area(cli1, cli2);
1322
1323 /* Ensure the file doesn't already exist. */
1324 smbcli_close(cli1->tree, fnum1);
1325 smbcli_close(cli1->tree, fnum2);
1326 smbcli_setatr(cli1->tree, fname, 0, 0);
1327 smbcli_unlink(cli1->tree, fname);
1328
1329
1330 /* Create the file with delete on close. */
1331 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1332 SEC_RIGHTS_FILE_ALL,
1333 FILE_ATTRIBUTE_NORMAL,
1334 NTCREATEX_SHARE_ACCESS_READ|
1335 NTCREATEX_SHARE_ACCESS_WRITE|
1336 NTCREATEX_SHARE_ACCESS_DELETE,
1337 NTCREATEX_DISP_CREATE,
1338 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1339
1340 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1341 fname, smbcli_errstr(cli1->tree)));
1342
1343 /* The delete on close bit is *not* reported as being set. */
1344 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1345
1346 /* Now try opening again for read-only. */
1347 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
1348 SEC_RIGHTS_FILE_READ|
1349 SEC_STD_DELETE,
1350 FILE_ATTRIBUTE_NORMAL,
1351 NTCREATEX_SHARE_ACCESS_READ|
1352 NTCREATEX_SHARE_ACCESS_WRITE|
1353 NTCREATEX_SHARE_ACCESS_DELETE,
1354 NTCREATEX_DISP_OPEN,
1355 0, 0);
1356
1357 /* Should work. */
1358 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1359 fname, smbcli_errstr(cli1->tree)));
1360
1361 /* still not reported as being set on either */
1362 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1363 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1364
1365 smbcli_close(cli1->tree, fnum2);
1366
1367 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1368
1369 smbcli_close(cli1->tree, fnum1);
1370
1371 /*
1372 * The file is still there:
1373 * The second open seems to have removed the initial
1374 * delete on close flag from the first handle
1375 */
1376 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1377 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open - 3 of %s succeed (should fail)",
1378 fname));
1379
1380 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1381
1382 return correct;
1383 }
1384
1385 static bool deltest17e(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1386 {
1387 int fnum1 = -1;
1388 int fnum2 = -1;
1389 int fnum3 = -1;
1390 bool correct = true;
1391
1392 del_clean_area(cli1, cli2);
1393
1394 /* Ensure the file doesn't already exist. */
1395 smbcli_close(cli1->tree, fnum1);
1396 smbcli_close(cli1->tree, fnum2);
1397 smbcli_setatr(cli1->tree, fname, 0, 0);
1398 smbcli_unlink(cli1->tree, fname);
1399
1400 /* Firstly open and create with all access */
1401 fnum3 = smbcli_nt_create_full(cli1->tree, fname, 0,
1402 SEC_RIGHTS_FILE_ALL,
1403 FILE_ATTRIBUTE_NORMAL,
1404 NTCREATEX_SHARE_ACCESS_READ|
1405 NTCREATEX_SHARE_ACCESS_WRITE|
1406 NTCREATEX_SHARE_ACCESS_DELETE,
1407 NTCREATEX_DISP_CREATE,
1408 0, 0);
1409 torture_assert(tctx, fnum3 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1410 fname, smbcli_errstr(cli1->tree)));
1411
1412 /* Next open with all access, but add delete on close. */
1413 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1414 SEC_RIGHTS_FILE_ALL,
1415 FILE_ATTRIBUTE_NORMAL,
1416 NTCREATEX_SHARE_ACCESS_READ|
1417 NTCREATEX_SHARE_ACCESS_WRITE|
1418 NTCREATEX_SHARE_ACCESS_DELETE,
1419 NTCREATEX_DISP_OPEN,
1420 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1421
1422 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1423 fname, smbcli_errstr(cli1->tree)));
1424
1425 /* The delete on close bit is *not* reported as being set. */
1426 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1427 correct &= check_delete_on_close(tctx, cli1, fnum3, fname, false, __location__);
1428
1429 /* Now try opening again for read-only. */
1430 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
1431 SEC_RIGHTS_FILE_READ|
1432 SEC_STD_DELETE,
1433 FILE_ATTRIBUTE_NORMAL,
1434 NTCREATEX_SHARE_ACCESS_READ|
1435 NTCREATEX_SHARE_ACCESS_WRITE|
1436 NTCREATEX_SHARE_ACCESS_DELETE,
1437 NTCREATEX_DISP_OPEN,
1438 0, 0);
1439
1440 /* Should work. */
1441 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 3 of %s failed (%s)",
1442 fname, smbcli_errstr(cli1->tree)));
1443
1444 /* still not reported as being set on either */
1445 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1446 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1447 correct &= check_delete_on_close(tctx, cli1, fnum3, fname, false, __location__);
1448
1449 smbcli_close(cli1->tree, fnum1);
1450
1451 /*
1452 * closing the handle that has delete_on_close set
1453 * inherits the flag to the global context
1454 */
1455 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, true, __location__);
1456 correct &= check_delete_on_close(tctx, cli1, fnum3, fname, true, __location__);
1457
1458 smbcli_close(cli1->tree, fnum2);
1459
1460 correct &= check_delete_on_close(tctx, cli1, fnum3, fname, true, __location__);
1461
1462 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1463 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open - 4 of %s succeeded (should fail)",
1464 fname));
1465
1466 CHECK_STATUS(cli1, NT_STATUS_DELETE_PENDING);
1467
1468 smbcli_close(cli1->tree, fnum3);
1469
1470 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1471 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open - 5 of %s succeeded (should fail)",
1472 fname));
1473
1474 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1475
1476 return correct;
1477 }
1478
1479 static bool deltest17f(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1480 {
1481 int fnum1 = -1;
1482 int fnum2 = -1;
1483 int fnum3 = -1;
1484 bool correct = true;
1485 NTSTATUS status;
1486
1487 del_clean_area(cli1, cli2);
1488
1489 /* Ensure the file doesn't already exist. */
1490 smbcli_close(cli1->tree, fnum1);
1491 smbcli_close(cli1->tree, fnum2);
1492 smbcli_setatr(cli1->tree, fname, 0, 0);
1493 smbcli_unlink(cli1->tree, fname);
1494
1495 /* Firstly open and create with all access */
1496 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1497 SEC_RIGHTS_FILE_ALL,
1498 FILE_ATTRIBUTE_NORMAL,
1499 NTCREATEX_SHARE_ACCESS_READ|
1500 NTCREATEX_SHARE_ACCESS_WRITE|
1501 NTCREATEX_SHARE_ACCESS_DELETE,
1502 NTCREATEX_DISP_CREATE,
1503 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1504 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1505 fname, smbcli_errstr(cli1->tree)));
1506
1507 /* The delete on close bit is *not* reported as being set. */
1508 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1509
1510 /* Next open with all access, but add delete on close. */
1511 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
1512 SEC_RIGHTS_FILE_ALL,
1513 FILE_ATTRIBUTE_NORMAL,
1514 NTCREATEX_SHARE_ACCESS_READ|
1515 NTCREATEX_SHARE_ACCESS_WRITE|
1516 NTCREATEX_SHARE_ACCESS_DELETE,
1517 NTCREATEX_DISP_OPEN,
1518 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1519
1520 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1521 fname, smbcli_errstr(cli1->tree)));
1522
1523 /* still not reported as being set on either */
1524 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1525 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1526
1527 /* Now try opening again for read-only. */
1528 fnum3 = smbcli_nt_create_full(cli1->tree, fname, 0,
1529 SEC_RIGHTS_FILE_READ|
1530 SEC_STD_DELETE,
1531 FILE_ATTRIBUTE_NORMAL,
1532 NTCREATEX_SHARE_ACCESS_READ|
1533 NTCREATEX_SHARE_ACCESS_WRITE|
1534 NTCREATEX_SHARE_ACCESS_DELETE,
1535 NTCREATEX_DISP_OPEN,
1536 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1537
1538 /* Should work. */
1539 torture_assert(tctx, fnum3 != -1, talloc_asprintf(tctx, "open - 3 of %s failed (%s)",
1540 fname, smbcli_errstr(cli1->tree)));
1541
1542 /* still not reported as being set on either */
1543 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1544 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1545 correct &= check_delete_on_close(tctx, cli1, fnum3, fname, false, __location__);
1546
1547 smbcli_close(cli1->tree, fnum1);
1548
1549 /*
1550 * closing the handle that has delete_on_close set
1551 * inherits the flag to the global context
1552 */
1553 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, true, __location__);
1554 correct &= check_delete_on_close(tctx, cli1, fnum3, fname, true, __location__);
1555
1556
1557 status = smbcli_nt_delete_on_close(cli1->tree, fnum2, false);
1558 torture_assert_ntstatus_ok(tctx, status,
1559 "clearing delete_on_close on file failed !");
1560
1561 correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
1562 correct &= check_delete_on_close(tctx, cli1, fnum3, fname, false, __location__);
1563
1564 smbcli_close(cli1->tree, fnum2);
1565
1566 correct &= check_delete_on_close(tctx, cli1, fnum3, fname, true, __location__);
1567
1568 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1569 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open - 4 of %s succeeded (should fail)",
1570 fname));
1571
1572 CHECK_STATUS(cli1, NT_STATUS_DELETE_PENDING);
1573
1574 smbcli_close(cli1->tree, fnum3);
1575
1576 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1577 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open - 5 of %s succeeded (should fail)",
1578 fname));
1579
1580 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1581
1582 return correct;
1583 }
1584
1585 /* Test 18 ... */
1586 static bool deltest18(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1587 {
1588 int fnum1 = -1;
1589 int fnum2 = -1;
1590 bool correct = true;
1591
1592 del_clean_area(cli1, cli2);
1593
1594 /* Test 18. With directories. */
1595
1596 /* Ensure the file doesn't already exist. */
1597 smbcli_close(cli1->tree, fnum1);
1598 smbcli_close(cli1->tree, fnum2);
1599
1600 smbcli_deltree(cli1->tree, dname);
1601
1602 /* Firstly create with all access, but delete on close. */
1603 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1604 SEC_FILE_READ_DATA|
1605 SEC_FILE_WRITE_DATA|
1606 SEC_STD_DELETE,
1607 FILE_ATTRIBUTE_DIRECTORY,
1608 NTCREATEX_SHARE_ACCESS_READ|
1609 NTCREATEX_SHARE_ACCESS_WRITE|
1610 NTCREATEX_SHARE_ACCESS_DELETE,
1611 NTCREATEX_DISP_CREATE,
1612 NTCREATEX_OPTIONS_DIRECTORY|NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1613
1614 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1615 dname, smbcli_errstr(cli1->tree)));
1616
1617 /*
1618 * The delete on close bit is *not* reported as being set.
1619 * Win2k3/win2k8 should pass this check, but WinXPsp2 reports delete on
1620 * close as being set. This causes the subsequent create to fail with
1621 * NT_STATUS_DELETE_PENDING.
1622 */
1623 correct &= check_delete_on_close(tctx, cli1, fnum1, dname, false, __location__);
1624
1625 /* Now try opening again for read-only. */
1626 fnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
1627 SEC_RIGHTS_FILE_READ,
1628 FILE_ATTRIBUTE_DIRECTORY,
1629 NTCREATEX_SHARE_ACCESS_READ|
1630 NTCREATEX_SHARE_ACCESS_WRITE|
1631 NTCREATEX_SHARE_ACCESS_DELETE,
1632 NTCREATEX_DISP_OPEN,
1633 NTCREATEX_OPTIONS_DIRECTORY, 0);
1634
1635
1636 /* Should work. */
1637 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1638 dname, smbcli_errstr(cli1->tree)));
1639
1640 correct &= check_delete_on_close(tctx, cli1, fnum1, dname, false, __location__);
1641 correct &= check_delete_on_close(tctx, cli1, fnum2, dname, false, __location__);
1642
1643 smbcli_close(cli1->tree, fnum1);
1644
1645 correct &= check_delete_on_close(tctx, cli1, fnum2, dname, true, __location__);
1646
1647 smbcli_close(cli1->tree, fnum2);
1648
1649 /* And the directory should be deleted ! */
1650 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1651 SEC_RIGHTS_FILE_READ,
1652 FILE_ATTRIBUTE_DIRECTORY,
1653 NTCREATEX_SHARE_ACCESS_READ|
1654 NTCREATEX_SHARE_ACCESS_WRITE|
1655 NTCREATEX_SHARE_ACCESS_DELETE,
1656 NTCREATEX_DISP_OPEN,
1657 NTCREATEX_OPTIONS_DIRECTORY, 0);
1658 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail)",
1659 dname));
1660
1661 return correct;
1662 }
1663
1664 /* Test 19 ... */
1665 static bool deltest19(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1666 {
1667 int fnum1 = -1;
1668 int fnum2 = -1;
1669 bool correct = true;
1670
1671 del_clean_area(cli1, cli2);
1672
1673 /* Test 19. */
1674
1675 smbcli_deltree(cli1->tree, dname);
1676
1677 /* Firstly open and create with all access */
1678 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1679 SEC_FILE_READ_DATA|
1680 SEC_FILE_WRITE_DATA|
1681 SEC_STD_DELETE,
1682 FILE_ATTRIBUTE_DIRECTORY,
1683 NTCREATEX_SHARE_ACCESS_READ|
1684 NTCREATEX_SHARE_ACCESS_WRITE|
1685 NTCREATEX_SHARE_ACCESS_DELETE,
1686 NTCREATEX_DISP_CREATE,
1687 NTCREATEX_OPTIONS_DIRECTORY, 0);
1688
1689 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1690 dname, smbcli_errstr(cli1->tree)));
1691
1692 /* And close - just to create the directory. */
1693 smbcli_close(cli1->tree, fnum1);
1694
1695 /* Next open with all access, but add delete on close. */
1696 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1697 SEC_FILE_READ_DATA|
1698 SEC_FILE_WRITE_DATA|
1699 SEC_STD_DELETE,
1700 FILE_ATTRIBUTE_DIRECTORY,
1701 NTCREATEX_SHARE_ACCESS_READ|
1702 NTCREATEX_SHARE_ACCESS_WRITE|
1703 NTCREATEX_SHARE_ACCESS_DELETE,
1704 NTCREATEX_DISP_OPEN,
1705 NTCREATEX_OPTIONS_DIRECTORY|NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1706
1707 torture_assert(tctx, fnum1 != -1,
1708 talloc_asprintf(tctx, "open - 1 of %s failed (%s)", fname, smbcli_errstr(cli1->tree)));
1709
1710 /*
1711 * The delete on close bit is *not* reported as being set.
1712 * Win2k3/win2k8 should pass this check, but WinXPsp2 reports delete on
1713 * close as being set. This causes the subsequent create to fail with
1714 * NT_STATUS_DELETE_PENDING.
1715 */
1716 correct &= check_delete_on_close(tctx, cli1, fnum1, dname, false, __location__);
1717
1718 /* Now try opening again for read-only. */
1719 fnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
1720 SEC_RIGHTS_FILE_READ,
1721 FILE_ATTRIBUTE_DIRECTORY,
1722 NTCREATEX_SHARE_ACCESS_READ|
1723 NTCREATEX_SHARE_ACCESS_WRITE|
1724 NTCREATEX_SHARE_ACCESS_DELETE,
1725 NTCREATEX_DISP_OPEN,
1726 NTCREATEX_OPTIONS_DIRECTORY, 0);
1727
1728 /* Should work. */
1729 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1730 dname, smbcli_errstr(cli1->tree)));
1731
1732 smbcli_close(cli1->tree, fnum1);
1733
1734 correct &= check_delete_on_close(tctx, cli1, fnum2, dname, true, __location__);
1735
1736 smbcli_close(cli1->tree, fnum2);
1737
1738 /* See if the file is deleted - for a directory this seems to be true ! */
1739 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1740 SEC_RIGHTS_FILE_READ,
1741 FILE_ATTRIBUTE_DIRECTORY,
1742 NTCREATEX_SHARE_ACCESS_READ|
1743 NTCREATEX_SHARE_ACCESS_WRITE|
1744 NTCREATEX_SHARE_ACCESS_DELETE,
1745 NTCREATEX_DISP_OPEN,
1746 NTCREATEX_OPTIONS_DIRECTORY, 0);
1747
1748 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1749
1750 torture_assert(tctx, fnum1 == -1,
1751 talloc_asprintf(tctx, "open of %s succeeded (should fail)", dname));
1752
1753 return correct;
1754 }
1755
1756 /* Test 20 ... */
1757 static bool deltest20(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1758 {
1759 int fnum1 = -1;
1760 int dnum1 = -1;
1761 bool correct = true;
1762 NTSTATUS status;
1763
1764 del_clean_area(cli1, cli2);
1765
1766 /* Test 20 -- non-empty directory hardest to get right... */
1767
1768 if (torture_setting_bool(tctx, "samba3", false)) {
1769 return true;
1770 }
1771
1772 smbcli_deltree(cli1->tree, dname);
1773
1774 dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1775 SEC_FILE_READ_DATA|
1776 SEC_FILE_WRITE_DATA|
1777 SEC_STD_DELETE,
1778 FILE_ATTRIBUTE_DIRECTORY,
1779 NTCREATEX_SHARE_ACCESS_READ|
1780 NTCREATEX_SHARE_ACCESS_WRITE|
1781 NTCREATEX_SHARE_ACCESS_DELETE,
1782 NTCREATEX_DISP_CREATE,
1783 NTCREATEX_OPTIONS_DIRECTORY, 0);
1784 torture_assert(tctx, dnum1 != -1, talloc_asprintf(tctx, "open of %s failed: %s!",
1785 dname, smbcli_errstr(cli1->tree)));
1786
1787 correct &= check_delete_on_close(tctx, cli1, dnum1, dname, false, __location__);
1788 status = smbcli_nt_delete_on_close(cli1->tree, dnum1, true);
1789
1790 {
1791 char *fullname;
1792 asprintf(&fullname, "\\%s%s", dname, fname);
1793 fnum1 = smbcli_open(cli1->tree, fullname, O_CREAT|O_RDWR,
1794 DENY_NONE);
1795 torture_assert(tctx, fnum1 == -1,
1796 "smbcli_open succeeded, should have "
1797 "failed with NT_STATUS_DELETE_PENDING"
1798 );
1799
1800 torture_assert_ntstatus_equal(tctx,
1801 smbcli_nt_error(cli1->tree),
1802 NT_STATUS_DELETE_PENDING,
1803 "smbcli_open failed");
1804 }
1805
1806 status = smbcli_nt_delete_on_close(cli1->tree, dnum1, false);
1807 torture_assert_ntstatus_ok(tctx, status,
1808 "setting delete_on_close on file failed !");
1809
1810 {
1811 char *fullname;
1812 asprintf(&fullname, "\\%s%s", dname, fname);
1813 fnum1 = smbcli_open(cli1->tree, fullname, O_CREAT|O_RDWR,
1814 DENY_NONE);
1815 torture_assert(tctx, fnum1 != -1,
1816 talloc_asprintf(tctx, "smbcli_open failed: %s\n",
1817 smbcli_errstr(cli1->tree)));
1818 smbcli_close(cli1->tree, fnum1);
1819 }
1820
1821 status = smbcli_nt_delete_on_close(cli1->tree, dnum1, true);
1822
1823 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_DIRECTORY_NOT_EMPTY,
1824 "setting delete_on_close failed");
1825 smbcli_close(cli1->tree, dnum1);
1826
1827 return correct;
1828 }
1829
1830 /* Test 20a ... */
1831 static bool deltest20a(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1832 {
1833 int fnum1 = -1;
1834 int fnum2 = -1;
1835 bool correct = true;
1836
1837 del_clean_area(cli1, cli2);
1838
1839 /* Test 20a. */
1840
1841 /* Ensure the file doesn't already exist. */
1842 smbcli_close(cli1->tree, fnum1);
1843 smbcli_close(cli1->tree, fnum2);
1844 smbcli_setatr(cli1->tree, fname, 0, 0);
1845 smbcli_unlink(cli1->tree, fname);
1846
1847 /* Firstly open and create with all access */
1848 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1849 SEC_RIGHTS_FILE_ALL,
1850 FILE_ATTRIBUTE_NORMAL,
1851 NTCREATEX_SHARE_ACCESS_READ|
1852 NTCREATEX_SHARE_ACCESS_WRITE|
1853 NTCREATEX_SHARE_ACCESS_DELETE,
1854 NTCREATEX_DISP_CREATE,
1855 0, 0);
1856 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1857 fname, smbcli_errstr(cli1->tree)));
1858
1859 /* Next open with all access, but add delete on close. */
1860 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
1861 SEC_RIGHTS_FILE_ALL,
1862 FILE_ATTRIBUTE_NORMAL,
1863 NTCREATEX_SHARE_ACCESS_READ|
1864 NTCREATEX_SHARE_ACCESS_WRITE|
1865 NTCREATEX_SHARE_ACCESS_DELETE,
1866 NTCREATEX_DISP_OPEN,
1867 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1868
1869 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1870 fname, smbcli_errstr(cli2->tree)));
1871
1872 /* The delete on close bit is *not* reported as being set. */
1873 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1874 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
1875
1876 smbcli_close(cli1->tree, fnum1);
1877
1878 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
1879
1880 smbcli_close(cli2->tree, fnum2);
1881
1882 /* See if the file is deleted - should be.... */
1883 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1884 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail) - %s",
1885 fname, smbcli_errstr(cli1->tree)));
1886
1887 return correct;
1888 }
1889
1890 /* Test 20b ... */
1891 /* This is the delete semantics that the cifsfs client depends on when
1892 * trying to delete an open file on a Windows server. It
1893 * opens a file with initial delete on close set, renames it then closes
1894 * all open handles. The file goes away on Windows.
1895 */
1896
1897 static bool deltest20b(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1898 {
1899 int fnum1 = -1;
1900 int fnum2 = -1;
1901 bool correct = true;
1902
1903 del_clean_area(cli1, cli2);
1904
1905 /* Test 20b. */
1906
1907 /* Ensure the file doesn't already exist. */
1908 smbcli_close(cli1->tree, fnum1);
1909 smbcli_close(cli1->tree, fnum2);
1910 smbcli_setatr(cli1->tree, fname, 0, 0);
1911 smbcli_unlink(cli1->tree, fname);
1912 smbcli_setatr(cli1->tree, fname_new, 0, 0);
1913 smbcli_unlink(cli1->tree, fname_new);
1914
1915 /* Firstly open and create with all access */
1916 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1917 SEC_RIGHTS_FILE_ALL,
1918 FILE_ATTRIBUTE_NORMAL,
1919 NTCREATEX_SHARE_ACCESS_READ|
1920 NTCREATEX_SHARE_ACCESS_WRITE|
1921 NTCREATEX_SHARE_ACCESS_DELETE,
1922 NTCREATEX_DISP_CREATE,
1923 0, 0);
1924 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1925 fname, smbcli_errstr(cli1->tree)));
1926
1927 /* And close - just to create the file. */
1928 smbcli_close(cli1->tree, fnum1);
1929
1930 /* Firstly open and create with all access */
1931 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1932 SEC_RIGHTS_FILE_ALL,
1933 FILE_ATTRIBUTE_NORMAL,
1934 NTCREATEX_SHARE_ACCESS_READ|
1935 NTCREATEX_SHARE_ACCESS_WRITE|
1936 NTCREATEX_SHARE_ACCESS_DELETE,
1937 NTCREATEX_DISP_OPEN,
1938 0, 0);
1939 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1940 fname, smbcli_errstr(cli1->tree)));
1941
1942 /* Next open with all access, but add delete on close. */
1943 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
1944 SEC_RIGHTS_FILE_ALL,
1945 FILE_ATTRIBUTE_NORMAL,
1946 NTCREATEX_SHARE_ACCESS_READ|
1947 NTCREATEX_SHARE_ACCESS_WRITE|
1948 NTCREATEX_SHARE_ACCESS_DELETE,
1949 NTCREATEX_DISP_OPEN,
1950 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1951
1952 torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1953 fname, smbcli_errstr(cli2->tree)));
1954
1955 /* The delete on close bit is *not* reported as being set. */
1956 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1957 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
1958
1959 smbcli_close(cli1->tree, fnum1);
1960
1961 correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
1962
1963 /* Rename the file by handle. */
1964
1965 {
1966 union smb_setfileinfo sfinfo;
1967 NTSTATUS status;
1968
1969 memset(&sfinfo, '\0', sizeof(sfinfo));
1970 sfinfo.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
1971 sfinfo.generic.in.file.fnum = fnum2;
1972 sfinfo.rename_information.in.root_fid = 0;
1973 /* Don't start the filename with '\\', we get NT_STATUS_NOT_SUPPORTED if so. */
1974 sfinfo.rename_information.in.new_name = fname_new + 1;
1975 sfinfo.rename_information.in.overwrite = 1;
1976
1977 status = smb_raw_setfileinfo(cli2->tree, &sfinfo);
1978
1979 torture_assert_ntstatus_equal(tctx,status,NT_STATUS_OK,talloc_asprintf(tctx, "rename of %s to %s failed (%s)",
1980 fname, fname_new, smbcli_errstr(cli2->tree)));
1981 }
1982
1983 correct &= check_delete_on_close(tctx, cli2, fnum2, fname_new, false, __location__);
1984
1985 smbcli_close(cli2->tree, fnum2);
1986
1987 /* See if the file is deleted - should be.... */
1988 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1989 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail) - %s",
1990 fname, smbcli_errstr(cli1->tree)));
1991 fnum1 = smbcli_open(cli1->tree, fname_new, O_RDWR, DENY_NONE);
1992 torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail) - %s",
1993 fname_new, smbcli_errstr(cli1->tree)));
1994
1995 return correct;
1996 }
1997
1998
1999 /* Test 21 ... */
2000 static bool deltest21(struct torture_context *tctx)
2001 {
2002 int fnum1 = -1;
2003 struct smbcli_state *cli1;
2004 struct smbcli_state *cli2;
2005 bool correct = true;
2006
2007 if (!torture_open_connection(&cli1, tctx, 0))
2008 return false;
2009
2010 if (!torture_open_connection(&cli2, tctx, 1))
2011 return false;
2012
2013 del_clean_area(cli1, cli2);
2014
2015 /* Test 21 -- Test removal of file after socket close. */
2016
2017 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
2018 SEC_RIGHTS_FILE_ALL,
2019 FILE_ATTRIBUTE_NORMAL, NTCREATEX_SHARE_ACCESS_NONE,
2020 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
2021
2022 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
2023 fname, smbcli_errstr(cli1->tree)));
2024
2025 torture_assert_ntstatus_ok(tctx,
2026 smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
2027 talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
2028 smbcli_errstr(cli1->tree)));
2029
2030 /* Ensure delete on close is set. */
2031 correct &= check_delete_on_close(tctx, cli1, fnum1, fname, true, __location__);
2032
2033 /* Now yank the rug from under cli1. */
2034 smbcli_transport_dead(cli1->transport, NT_STATUS_LOCAL_DISCONNECT);
2035
2036 fnum1 = -1;
2037
2038 if (!torture_open_connection(&cli1, tctx, 0)) {
2039 return false;
2040 }
2041
2042 /* On slow build farm machines it might happen that they are not fast
2043 * enogh to delete the file for this test */
2044 smb_msleep(200);
2045
2046 /* File should not be there. */
2047 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
2048 SEC_RIGHTS_FILE_READ,
2049 FILE_ATTRIBUTE_NORMAL,
2050 NTCREATEX_SHARE_ACCESS_READ|
2051 NTCREATEX_SHARE_ACCESS_WRITE|
2052 NTCREATEX_SHARE_ACCESS_DELETE,
2053 NTCREATEX_DISP_OPEN,
2054 0, 0);
2055
2056 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
2057
2058 return correct;
2059 }
2060
2061 /* Test 22 ... */
2062
2063 /*
2064 * Test whether a second *directory* handle inhibits delete if the first has
2065 * del-on-close set and is closed
2066 */
2067 static bool deltest22(struct torture_context *tctx)
2068 {
2069 int dnum1 = -1;
2070 int dnum2 = -1;
2071 struct smbcli_state *cli1;
2072 bool correct = true;
2073
2074 if (!torture_open_connection(&cli1, tctx, 0))
2075 return false;
2076
2077 smbcli_deltree(cli1->tree, dname);
2078
2079 torture_assert_ntstatus_ok(
2080 tctx, smbcli_mkdir(cli1->tree, dname),
2081 talloc_asprintf(tctx, "smbcli_mdir failed: (%s)\n",
2082 smbcli_errstr(cli1->tree)));
2083
2084 dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
2085 SEC_FILE_READ_DATA|
2086 SEC_FILE_WRITE_DATA|
2087 SEC_STD_DELETE,
2088 FILE_ATTRIBUTE_DIRECTORY,
2089 NTCREATEX_SHARE_ACCESS_READ|
2090 NTCREATEX_SHARE_ACCESS_WRITE|
2091 NTCREATEX_SHARE_ACCESS_DELETE,
2092 NTCREATEX_DISP_OPEN,
2093 NTCREATEX_OPTIONS_DIRECTORY, 0);
2094
2095 torture_assert(tctx, dnum1 != -1,
2096 talloc_asprintf(tctx, "open of %s failed: %s!",
2097 dname, smbcli_errstr(cli1->tree)));
2098
2099 dnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
2100 SEC_FILE_READ_DATA|
2101 SEC_FILE_WRITE_DATA,
2102 FILE_ATTRIBUTE_DIRECTORY,
2103 NTCREATEX_SHARE_ACCESS_READ|
2104 NTCREATEX_SHARE_ACCESS_WRITE|
2105 NTCREATEX_SHARE_ACCESS_DELETE,
2106 NTCREATEX_DISP_OPEN,
2107 NTCREATEX_OPTIONS_DIRECTORY, 0);
2108
2109 torture_assert(tctx, dnum2 != -1,
2110 talloc_asprintf(tctx, "open of %s failed: %s!",
2111 dname, smbcli_errstr(cli1->tree)));
2112
2113 torture_assert_ntstatus_ok(
2114 tctx, smbcli_nt_delete_on_close(cli1->tree, dnum1, true),
2115 talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
2116 smbcli_errstr(cli1->tree)));
2117
2118 smbcli_close(cli1->tree, dnum1);
2119
2120 dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
2121 SEC_FILE_READ_DATA|
2122 SEC_FILE_WRITE_DATA|
2123 SEC_STD_DELETE,
2124 FILE_ATTRIBUTE_DIRECTORY,
2125 NTCREATEX_SHARE_ACCESS_READ|
2126 NTCREATEX_SHARE_ACCESS_WRITE|
2127 NTCREATEX_SHARE_ACCESS_DELETE,
2128 NTCREATEX_DISP_OPEN,
2129 NTCREATEX_OPTIONS_DIRECTORY, 0);
2130
2131 torture_assert(tctx, dnum1 == -1,
2132 talloc_asprintf(tctx, "open of %s succeeded!\n",
2133 dname));
2134
2135 CHECK_STATUS(cli1, NT_STATUS_DELETE_PENDING);
2136
2137 smbcli_close(cli1->tree, dnum2);
2138 CHECK_STATUS(cli1, NT_STATUS_OK);
2139
2140 return correct;
2141 }
2142
2143 /* Test 23 - Second directory open fails when delete is pending. */
2144 static bool deltest23(struct torture_context *tctx,
2145 struct smbcli_state *cli1,
2146 struct smbcli_state *cli2)
2147 {
2148 int dnum1 = -1;
2149 int dnum2 = -1;
2150 bool correct = true;
2151
2152 del_clean_area(cli1, cli2);
2153
2154 /* Test 23 -- Basic delete on close for directories. */
2155
2156 /* Open a directory */
2157 dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
2158 SEC_FILE_READ_DATA|
2159 SEC_FILE_WRITE_DATA|
2160 SEC_STD_DELETE,
2161 FILE_ATTRIBUTE_DIRECTORY,
2162 NTCREATEX_SHARE_ACCESS_READ|
2163 NTCREATEX_SHARE_ACCESS_WRITE|
2164 NTCREATEX_SHARE_ACCESS_DELETE,
2165 NTCREATEX_DISP_CREATE,
2166 NTCREATEX_OPTIONS_DIRECTORY, 0);
2167
2168 torture_assert(tctx, dnum1 != -1, talloc_asprintf(tctx,
2169 "open of %s failed: %s!",
2170 dname, smbcli_errstr(cli1->tree)));
2171
2172 correct &= check_delete_on_close(tctx, cli1, dnum1, dname, false,
2173 __location__);
2174
2175 /* Set delete on close */
2176 (void)smbcli_nt_delete_on_close(cli1->tree, dnum1, true);
2177
2178 /* Attempt opening the directory again. It should fail. */
2179 dnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
2180 SEC_FILE_READ_DATA|
2181 SEC_FILE_WRITE_DATA|
2182 SEC_STD_DELETE,
2183 FILE_ATTRIBUTE_DIRECTORY,
2184 NTCREATEX_SHARE_ACCESS_READ|
2185 NTCREATEX_SHARE_ACCESS_WRITE|
2186 NTCREATEX_SHARE_ACCESS_DELETE,
2187 NTCREATEX_DISP_OPEN,
2188 NTCREATEX_OPTIONS_DIRECTORY, 0);
2189
2190 torture_assert(tctx, dnum2 == -1, talloc_asprintf(tctx,
2191 "open of %s succeeded: %s. It should have failed "
2192 "with NT_STATUS_DELETE_PENDING",
2193 dname, smbcli_errstr(cli1->tree)));
2194
2195 torture_assert_ntstatus_equal(tctx, smbcli_nt_error(cli1->tree),
2196 NT_STATUS_DELETE_PENDING, "smbcli_open failed");
2197
2198 return true;
2199 }
2200
2201 /*
2202 Test delete on close semantics.
2203 */
2204 struct torture_suite *torture_test_delete(void)
2205 {
2206 struct torture_suite *suite = torture_suite_create(
2207 talloc_autofree_context(), "delete");
2208
2209 torture_suite_add_2smb_test(suite, "deltest1", deltest1);
2210 torture_suite_add_2smb_test(suite, "deltest2", deltest2);
2211 torture_suite_add_2smb_test(suite, "deltest3", deltest3);
2212 torture_suite_add_2smb_test(suite, "deltest4", deltest4);
2213 torture_suite_add_2smb_test(suite, "deltest5", deltest5);
2214 torture_suite_add_2smb_test(suite, "deltest6", deltest6);
2215 torture_suite_add_2smb_test(suite, "deltest7", deltest7);
2216 torture_suite_add_2smb_test(suite, "deltest8", deltest8);
2217 torture_suite_add_2smb_test(suite, "deltest9", deltest9);
2218 torture_suite_add_2smb_test(suite, "deltest10", deltest10);
2219 torture_suite_add_2smb_test(suite, "deltest11", deltest11);
2220 torture_suite_add_2smb_test(suite, "deltest12", deltest12);
2221 torture_suite_add_2smb_test(suite, "deltest13", deltest13);
2222 torture_suite_add_2smb_test(suite, "deltest14", deltest14);
2223 torture_suite_add_2smb_test(suite, "deltest15", deltest15);
2224 torture_suite_add_2smb_test(suite, "deltest16", deltest16);
2225 torture_suite_add_2smb_test(suite, "deltest16a", deltest16a);
2226 torture_suite_add_2smb_test(suite, "deltest17", deltest17);
2227 torture_suite_add_2smb_test(suite, "deltest17a", deltest17a);
2228 torture_suite_add_2smb_test(suite, "deltest17b", deltest17b);
2229 torture_suite_add_2smb_test(suite, "deltest17c", deltest17c);
2230 torture_suite_add_2smb_test(suite, "deltest17d", deltest17d);
2231 torture_suite_add_2smb_test(suite, "deltest17e", deltest17e);
2232 torture_suite_add_2smb_test(suite, "deltest17f", deltest17f);
2233 torture_suite_add_2smb_test(suite, "deltest18", deltest18);
2234 torture_suite_add_2smb_test(suite, "deltest19", deltest19);
2235 torture_suite_add_2smb_test(suite, "deltest20", deltest20);
2236 torture_suite_add_2smb_test(suite, "deltest20a", deltest20a);
2237 torture_suite_add_2smb_test(suite, "deltest20b", deltest20b);
2238 torture_suite_add_simple_test(suite, "deltest21", deltest21);
2239 torture_suite_add_simple_test(suite, "deltest22", deltest22);
2240 torture_suite_add_2smb_test(suite, "deltest23", deltest23);
2241
2242 return suite;
2243 }
Samba GIT mirror