?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r16182: Better test the 15 out of 20 tests we right now survive than not test at
[Samba.git] / source / torture / basic / delete.c
blobc7b7fffa18acc1ce024fe1cdffa94d3dabe93796
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 2 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, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24 #include "libcli/libcli.h"
25 #include "torture/torture.h"
26 #include "torture/util.h"
27 #include "system/filesys.h"
28 #include "libcli/raw/libcliraw.h"
29
30 #include "torture/raw/proto.h"
31
32 static BOOL check_delete_on_close(struct smbcli_state *cli, int fnum,
33 const char *fname, BOOL expect_it,
34 const char *where)
35 {
36 TALLOC_CTX *mem_ctx = talloc_init("single_search");
37 union smb_search_data data;
38 NTSTATUS status;
39
40 time_t c_time, a_time, m_time;
41 size_t size;
42 uint16_t mode;
43
44 BOOL res = True;
45
46 status = torture_single_search(cli, mem_ctx,
47 fname, RAW_SEARCH_FULL_DIRECTORY_INFO,
48 FILE_ATTRIBUTE_DIRECTORY,
49 &data);
50 if (!NT_STATUS_IS_OK(status)) {
51 printf("(%s) single_search failed (%s)\n",
52 where, nt_errstr(status));
53 res = False;
54 goto done;
55 }
56
57 if (fnum != -1) {
58 union smb_fileinfo io;
59 int nlink = expect_it ? 0 : 1;
60
61 io.all_info.level = RAW_FILEINFO_ALL_INFO;
62 io.all_info.in.file.fnum = fnum;
63
64 status = smb_raw_fileinfo(cli->tree, mem_ctx, &io);
65 if (!NT_STATUS_IS_OK(status)) {
66 printf("(%s) qfileinfo failed (%s)\n", where,
67 nt_errstr(status));
68 res = False;
69 goto done;
70 }
71
72 if (expect_it != io.all_info.out.delete_pending) {
73 printf("%s - Expected del_on_close flag %d, qfileinfo/all_info gave %d\n",
74 where, expect_it, io.all_info.out.delete_pending);
75 res = False;
76 goto done;
77 }
78
79 if (nlink != io.all_info.out.nlink) {
80 printf("%s - Expected nlink %d, qfileinfo/all_info gave %d\n",
81 where, nlink, io.all_info.out.nlink);
82 res = False;
83 goto done;
84 }
85
86 io.standard_info.level = RAW_FILEINFO_STANDARD_INFO;
87 io.standard_info.in.file.fnum = fnum;
88
89 status = smb_raw_fileinfo(cli->tree, mem_ctx, &io);
90 if (!NT_STATUS_IS_OK(status)) {
91 printf("(%s) qpathinfo failed (%s)\n", where,
92 nt_errstr(status));
93 res = False;
94 goto done;
95 }
96
97 if (expect_it != io.standard_info.out.delete_pending) {
98 printf("%s - Expected del_on_close flag %d, qfileinfo/standard_info gave %d\n",
99 where, expect_it, io.standard_info.out.delete_pending);
100 res = False;
101 goto done;
102 }
103
104 if (nlink != io.standard_info.out.nlink) {
105 printf("%s - Expected nlink %d, qfileinfo/standard_info gave %d\n",
106 where, nlink, io.all_info.out.nlink);
107 res = False;
108 goto done;
109 }
110
111 }
112
113 status = smbcli_qpathinfo(cli->tree, fname,
114 &c_time, &a_time, &m_time,
115 &size, &mode);
116
117 if (expect_it) {
118 if (!NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
119 printf("(%s) qpathinfo did not give correct error "
120 "code (%s) -- NT_STATUS_DELETE_PENDING "
121 "expected\n", where,
122 nt_errstr(status));
123 res = False;
124 goto done;
125 }
126 } else {
127 if (!NT_STATUS_IS_OK(status)) {
128 printf("(%s) qpathinfo failed (%s)\n", where,
129 nt_errstr(status));
130 res = False;
131 goto done;
132 }
133 }
134
135 done:
136 talloc_free(mem_ctx);
137 return res;
138 }
139
140 #define CHECK_STATUS(_cli, _expected) do { \
141 if (!NT_STATUS_EQUAL(_cli->tree->session->transport->error.e.nt_status, _expected)) { \
142 printf("(%d) Incorrect status %s - should be %s\n", \
143 __LINE__, nt_errstr(_cli->tree->session->transport->error.e.nt_status), nt_errstr(_expected)); \
144 correct = False; \
145 goto fail; \
146 }} while (0)
147
148 static const char *fname = "\\delete.file";
149 static const char *fname_new = "\\delete.new";
150 static const char *dname = "\\delete.dir";
151
152 static void del_clean_area(struct smbcli_state *cli1, struct smbcli_state *cli2)
153 {
154 smbcli_deltree(cli1->tree, dname);
155 smbcli_setatr(cli1->tree, fname, 0, 0);
156 smbcli_unlink(cli1->tree, fname);
157 smbcli_setatr(cli1->tree, fname_new, 0, 0);
158 smbcli_unlink(cli1->tree, fname_new);
159
160 smb_raw_exit(cli1->session);
161 smb_raw_exit(cli2->session);
162 }
163
164 /* Test 1 - this should delete the file on close. */
165
166 static BOOL deltest1(struct smbcli_state *cli1, struct smbcli_state *cli2)
167 {
168 int fnum1 = -1;
169
170 del_clean_area(cli1, cli2);
171
172 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
173 SEC_RIGHTS_FILE_ALL,
174 FILE_ATTRIBUTE_NORMAL,
175 NTCREATEX_SHARE_ACCESS_DELETE, NTCREATEX_DISP_OVERWRITE_IF,
176 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
177
178 if (fnum1 == -1) {
179 printf("(%s) open of %s failed (%s)\n",
180 __location__, fname, smbcli_errstr(cli1->tree));
181 return False;
182 }
183
184 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
185 printf("(%s) close failed (%s)\n",
186 __location__, smbcli_errstr(cli1->tree));
187 return False;
188 }
189
190 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
191 if (fnum1 != -1) {
192 printf("(%s) open of %s succeeded (should fail)\n",
193 __location__, fname);
194 return False;
195 }
196
197 printf("first delete on close test succeeded.\n");
198 return True;
199 }
200
201 /* Test 2 - this should delete the file on close. */
202 static BOOL deltest2(struct smbcli_state *cli1, struct smbcli_state *cli2)
203 {
204 int fnum1 = -1;
205
206 del_clean_area(cli1, cli2);
207
208 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
209 SEC_RIGHTS_FILE_ALL,
210 FILE_ATTRIBUTE_NORMAL, NTCREATEX_SHARE_ACCESS_NONE,
211 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
212
213 if (fnum1 == -1) {
214 printf("(%s) open of %s failed (%s)\n",
215 __location__, fname, smbcli_errstr(cli1->tree));
216 return False;
217 }
218
219 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli1->tree, fnum1, True))) {
220 printf("(%s) setting delete_on_close failed (%s)\n",
221 __location__, smbcli_errstr(cli1->tree));
222 return False;
223 }
224
225 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
226 printf("(%s) close failed (%s)\n",
227 __location__, smbcli_errstr(cli1->tree));
228 return False;
229 }
230
231 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
232 if (fnum1 != -1) {
233 printf("(%s) open of %s succeeded should have been deleted on close !\n",
234 __location__, fname);
235 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
236 printf("(%s) close failed (%s)\n",
237 __location__, smbcli_errstr(cli1->tree));
238 return False;
239 }
240 smbcli_unlink(cli1->tree, fname);
241 } else {
242 printf("second delete on close test succeeded.\n");
243 }
244 return True;
245 }
246
247 /* Test 3 - ... */
248 static BOOL deltest3(struct smbcli_state *cli1, struct smbcli_state *cli2)
249 {
250 int fnum1 = -1;
251 int fnum2 = -1;
252
253 del_clean_area(cli1, cli2);
254
255 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
256 SEC_RIGHTS_FILE_ALL,
257 FILE_ATTRIBUTE_NORMAL,
258 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
259 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
260
261 if (fnum1 == -1) {
262 printf("(%s) open - 1 of %s failed (%s)\n",
263 __location__, fname, smbcli_errstr(cli1->tree));
264 return False;
265 }
266
267 /* This should fail with a sharing violation - open for delete is only compatible
268 with SHARE_DELETE. */
269
270 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
271 SEC_RIGHTS_FILE_READ,
272 FILE_ATTRIBUTE_NORMAL,
273 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
274 NTCREATEX_DISP_OPEN, 0, 0);
275
276 if (fnum2 != -1) {
277 printf("(%s) open - 2 of %s succeeded - should have failed.\n",
278 __location__, fname);
279 return False;
280 }
281
282 /* This should succeed. */
283
284 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
285 SEC_RIGHTS_FILE_READ,
286 FILE_ATTRIBUTE_NORMAL,
287 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
288 NTCREATEX_DISP_OPEN, 0, 0);
289
290 if (fnum2 == -1) {
291 printf("(%s) open - 2 of %s failed (%s)\n",
292 __location__, fname, smbcli_errstr(cli1->tree));
293 return False;
294 }
295
296 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli1->tree, fnum1, True))) {
297 printf("(%s) setting delete_on_close failed (%s)\n",
298 __location__, smbcli_errstr(cli1->tree));
299 return False;
300 }
301
302 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
303 printf("(%s) close 1 failed (%s)\n",
304 __location__, smbcli_errstr(cli1->tree));
305 return False;
306 }
307
308 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum2))) {
309 printf("(%s) close 2 failed (%s)\n",
310 __location__, smbcli_errstr(cli1->tree));
311 return False;
312 }
313
314 /* This should fail - file should no longer be there. */
315
316 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
317 if (fnum1 != -1) {
318 printf("(%s) open of %s succeeded should have been deleted on close !\n",
319 __location__, fname);
320 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
321 printf("(%s) close failed (%s)\n",
322 __location__, smbcli_errstr(cli1->tree));
323 }
324 smbcli_unlink(cli1->tree, fname);
325 return False;
326 } else {
327 printf("third delete on close test succeeded.\n");
328 }
329 return True;
330 }
331
332 /* Test 4 ... */
333 static BOOL deltest4(struct smbcli_state *cli1, struct smbcli_state *cli2)
334 {
335 int fnum1 = -1;
336 int fnum2 = -1;
337 BOOL correct = True;
338
339 del_clean_area(cli1, cli2);
340
341 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
342 SEC_FILE_READ_DATA |
343 SEC_FILE_WRITE_DATA |
344 SEC_STD_DELETE,
345 FILE_ATTRIBUTE_NORMAL,
346 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
347 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
348
349 if (fnum1 == -1) {
350 printf("(%s) open of %s failed (%s)\n",
351 __location__, fname, smbcli_errstr(cli1->tree));
352 return False;
353 }
354
355 /* This should succeed. */
356 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
357 SEC_RIGHTS_FILE_READ,
358 FILE_ATTRIBUTE_NORMAL,
359 NTCREATEX_SHARE_ACCESS_READ |
360 NTCREATEX_SHARE_ACCESS_WRITE |
361 NTCREATEX_SHARE_ACCESS_DELETE,
362 NTCREATEX_DISP_OPEN, 0, 0);
363 if (fnum2 == -1) {
364 printf("(%s) open - 2 of %s failed (%s)\n",
365 __location__, fname, smbcli_errstr(cli1->tree));
366 return False;
367 }
368
369 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum2))) {
370 printf("(%s) close - 1 failed (%s)\n",
371 __location__, smbcli_errstr(cli1->tree));
372 return False;
373 }
374
375 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli1->tree, fnum1, True))) {
376 printf("(%s) setting delete_on_close failed (%s)\n",
377 __location__, smbcli_errstr(cli1->tree));
378 return False;
379 }
380
381 /* This should fail - no more opens once delete on close set. */
382 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
383 SEC_RIGHTS_FILE_READ,
384 FILE_ATTRIBUTE_NORMAL,
385 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
386 NTCREATEX_DISP_OPEN, 0, 0);
387 if (fnum2 != -1) {
388 printf("(%s) open - 3 of %s succeeded ! Should have failed.\n",
389 __location__, fname );
390 return False;
391 }
392 CHECK_STATUS(cli1, NT_STATUS_DELETE_PENDING);
393
394 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
395 printf("(%s) close - 2 failed (%s)\n",
396 __location__, smbcli_errstr(cli1->tree));
397 return False;
398 }
399
400 printf("fourth delete on close test succeeded.\n");
401
402 fail:
403
404 return correct;
405 }
406
407 /* Test 5 ... */
408 static BOOL deltest5(struct smbcli_state *cli1, struct smbcli_state *cli2)
409 {
410 int fnum1 = -1;
411
412 del_clean_area(cli1, cli2);
413
414 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
415 if (fnum1 == -1) {
416 printf("(%s) open of %s failed (%s)\n",
417 __location__, fname, smbcli_errstr(cli1->tree));
418 return False;
419 }
420
421 /* This should fail - only allowed on NT opens with DELETE access. */
422
423 if (NT_STATUS_IS_OK(smbcli_nt_delete_on_close(cli1->tree, fnum1, True))) {
424 printf("(%s) setting delete_on_close on OpenX file succeeded - should fail !\n",
425 __location__);
426 return False;
427 }
428
429 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
430 printf("(%s) close - 2 failed (%s)\n",
431 __location__, smbcli_errstr(cli1->tree));
432 return False;
433 }
434
435 printf("fifth delete on close test succeeded.\n");
436 return True;
437 }
438
439 /* Test 6 ... */
440 static BOOL deltest6(struct smbcli_state *cli1, struct smbcli_state *cli2)
441 {
442 int fnum1 = -1;
443
444 del_clean_area(cli1, cli2);
445
446 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
447 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
448 FILE_ATTRIBUTE_NORMAL,
449 NTCREATEX_SHARE_ACCESS_READ |
450 NTCREATEX_SHARE_ACCESS_WRITE |
451 NTCREATEX_SHARE_ACCESS_DELETE,
452 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
453
454 if (fnum1 == -1) {
455 printf("(%s) open of %s failed (%s)\n",
456 __location__, fname, smbcli_errstr(cli1->tree));
457 return False;
458 }
459
460 /* This should fail - only allowed on NT opens with DELETE access. */
461
462 if (NT_STATUS_IS_OK(smbcli_nt_delete_on_close(cli1->tree, fnum1, True))) {
463 printf("(%s) setting delete_on_close on file with no delete access succeeded - should fail !\n",
464 __location__);
465 return False;
466 }
467
468 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
469 printf("(%s) close - 2 failed (%s)\n",
470 __location__, smbcli_errstr(cli1->tree));
471 return False;
472 }
473
474 printf("sixth delete on close test succeeded.\n");
475 return True;
476 }
477
478 /* Test 7 ... */
479 static BOOL deltest7(struct smbcli_state *cli1, struct smbcli_state *cli2)
480 {
481 int fnum1 = -1;
482 BOOL correct = True;
483
484 del_clean_area(cli1, cli2);
485
486 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
487 SEC_FILE_READ_DATA |
488 SEC_FILE_WRITE_DATA |
489 SEC_STD_DELETE,
490 FILE_ATTRIBUTE_NORMAL, 0,
491 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
492
493 if (fnum1 == -1) {
494 printf("(%s) open of %s failed (%s)\n",
495 __location__, fname, smbcli_errstr(cli1->tree));
496 correct = False;
497 goto fail;
498 }
499
500 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli1->tree, fnum1, True))) {
501 printf("(%s) setting delete_on_close on file failed !\n",
502 __location__);
503 correct = False;
504 goto fail;
505 }
506
507 correct &= check_delete_on_close(cli1, fnum1, fname, True, __location__);
508
509 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli1->tree, fnum1, False))) {
510 printf("(%s) unsetting delete_on_close on file failed !\n",
511 __location__);
512 correct = False;
513 goto fail;
514 }
515
516 correct &= check_delete_on_close(cli1, fnum1, fname, False, __location__);
517
518 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
519 printf("(%s) close - 2 failed (%s)\n",
520 __location__, smbcli_errstr(cli1->tree));
521 correct = False;
522 goto fail;
523 }
524
525 /* This next open should succeed - we reset the flag. */
526
527 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
528 if (fnum1 == -1) {
529 printf("(%s) open of %s failed (%s)\n",
530 __location__, fname, smbcli_errstr(cli1->tree));
531 correct = False;
532 goto fail;
533 }
534
535 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
536 printf("(%s) close - 2 failed (%s)\n",
537 __location__, smbcli_errstr(cli1->tree));
538 correct = False;
539 goto fail;
540 }
541
542 printf("seventh delete on close test succeeded.\n");
543
544 fail:
545
546 return correct;
547 }
548
549 /* Test 8 ... */
550 static BOOL deltest8(struct smbcli_state *cli1, struct smbcli_state *cli2)
551 {
552 int fnum1 = -1;
553 int fnum2 = -1;
554 BOOL correct = True;
555
556 del_clean_area(cli1, cli2);
557
558 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
559 SEC_FILE_READ_DATA|
560 SEC_FILE_WRITE_DATA|
561 SEC_STD_DELETE,
562 FILE_ATTRIBUTE_NORMAL,
563 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
564 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
565
566 if (fnum1 == -1) {
567 printf("(%s) open of %s failed (%s)\n",
568 __location__, fname, smbcli_errstr(cli1->tree));
569 correct = False;
570 goto fail;
571 }
572
573 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
574 SEC_FILE_READ_DATA|
575 SEC_FILE_WRITE_DATA|
576 SEC_STD_DELETE,
577 FILE_ATTRIBUTE_NORMAL,
578 NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
579 NTCREATEX_DISP_OPEN, 0, 0);
580
581 if (fnum2 == -1) {
582 printf("(%s) open of %s failed (%s)\n",
583 __location__, fname, smbcli_errstr(cli1->tree));
584 correct = False;
585 goto fail;
586 }
587
588 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli1->tree, fnum1, True))) {
589 printf("(%s) setting delete_on_close on file failed !\n",
590 __location__);
591 correct = False;
592 goto fail;
593 }
594
595 correct &= check_delete_on_close(cli1, fnum1, fname, True, __location__);
596 correct &= check_delete_on_close(cli2, fnum2, fname, True, __location__);
597
598 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
599 printf("(%s) close - 1 failed (%s)\n",
600 __location__, smbcli_errstr(cli1->tree));
601 correct = False;
602 goto fail;
603 }
604
605 correct &= check_delete_on_close(cli1, -1, fname, True, __location__);
606 correct &= check_delete_on_close(cli2, fnum2, fname, True, __location__);
607
608 if (NT_STATUS_IS_ERR(smbcli_close(cli2->tree, fnum2))) {
609 printf("(%s) close - 2 failed (%s)\n",
610 __location__, smbcli_errstr(cli2->tree));
611 correct = False;
612 goto fail;
613 }
614
615 /* This should fail.. */
616 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
617 if (fnum1 != -1) {
618 printf("(%s) open of %s succeeded should have been deleted on close !\n",
619 __location__, fname);
620 correct = False;
621 } else {
622 printf("eighth delete on close test succeeded.\n");
623 }
624
625 fail:
626
627 return correct;
628 }
629
630 /* Test 9 ... */
631 static BOOL deltest9(struct smbcli_state *cli1, struct smbcli_state *cli2)
632 {
633 int fnum1 = -1;
634
635 del_clean_area(cli1, cli2);
636
637 /* This should fail - we need to set DELETE_ACCESS. */
638 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
639 SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA,
640 FILE_ATTRIBUTE_NORMAL,
641 NTCREATEX_SHARE_ACCESS_NONE,
642 NTCREATEX_DISP_OVERWRITE_IF,
643 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
644
645 if (fnum1 != -1) {
646 printf("(%s) open of %s succeeded should have failed!\n",
647 __location__, fname);
648 return False;
649 }
650
651 printf("ninth delete on close test succeeded.\n");
652 return True;
653 }
654
655 /* Test 10 ... */
656 static BOOL deltest10(struct smbcli_state *cli1, struct smbcli_state *cli2)
657 {
658 int fnum1 = -1;
659 BOOL correct = True;
660
661 del_clean_area(cli1, cli2);
662
663 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
664 SEC_FILE_READ_DATA|
665 SEC_FILE_WRITE_DATA|
666 SEC_STD_DELETE,
667 FILE_ATTRIBUTE_NORMAL,
668 NTCREATEX_SHARE_ACCESS_NONE,
669 NTCREATEX_DISP_OVERWRITE_IF,
670 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
671 if (fnum1 == -1) {
672 printf("(%s) open of %s failed (%s)\n",
673 __location__, fname, smbcli_errstr(cli1->tree));
674 correct = False;
675 goto fail;
676 }
677
678 /* This should delete the file. */
679 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
680 printf("(%s) close failed (%s)\n",
681 __location__, smbcli_errstr(cli1->tree));
682 correct = False;
683 goto fail;
684 }
685
686 /* This should fail.. */
687 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
688 if (fnum1 != -1) {
689 printf("(%s) open of %s succeeded should have been deleted on close !\n",
690 __location__, fname);
691 correct = False;
692 goto fail;
693 } else {
694 printf("tenth delete on close test succeeded.\n");
695 }
696
697 fail:
698
699 return correct;
700 }
701
702 /* Test 11 ... */
703 static BOOL deltest11(struct smbcli_state *cli1, struct smbcli_state *cli2)
704 {
705 int fnum1 = -1;
706 NTSTATUS status;
707
708 del_clean_area(cli1, cli2);
709
710 /* test 11 - does having read only attribute still allow delete on close. */
711
712 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
713 SEC_RIGHTS_FILE_ALL,
714 FILE_ATTRIBUTE_READONLY,
715 NTCREATEX_SHARE_ACCESS_NONE,
716 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
717
718 if (fnum1 == -1) {
719 printf("(%s) open of %s failed (%s)\n",
720 __location__, fname, smbcli_errstr(cli1->tree));
721 return False;
722 }
723
724 status = smbcli_nt_delete_on_close(cli1->tree, fnum1, True);
725
726 if (!NT_STATUS_EQUAL(status, NT_STATUS_CANNOT_DELETE)) {
727 printf("(%s) setting delete_on_close should fail with NT_STATUS_CANNOT_DELETE. Got %s instead)\n",
728 __location__, smbcli_errstr(cli1->tree));
729 return False;
730 }
731
732 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
733 printf("(%s) close failed (%s)\n",
734 __location__, smbcli_errstr(cli1->tree));
735 return False;
736 }
737
738 printf("eleventh delete on close test succeeded.\n");
739 return True;
740 }
741
742 /* Test 12 ... */
743 static BOOL deltest12(struct smbcli_state *cli1, struct smbcli_state *cli2)
744 {
745 int fnum1 = -1;
746 NTSTATUS status;
747
748 del_clean_area(cli1, cli2);
749
750 /* test 12 - does having read only attribute still allow delete on
751 * close at time of open. */
752
753 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
754 SEC_RIGHTS_FILE_ALL,
755 FILE_ATTRIBUTE_READONLY,
756 NTCREATEX_SHARE_ACCESS_DELETE,
757 NTCREATEX_DISP_OVERWRITE_IF,
758 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
759
760 if (fnum1 != -1) {
761 printf("(%s) open of %s succeeded. Should fail with "
762 "NT_STATUS_CANNOT_DELETE.\n", __location__, fname);
763 smbcli_close(cli1->tree, fnum1);
764 return False;
765 } else {
766 status = smbcli_nt_error(cli1->tree);
767 if (!NT_STATUS_EQUAL(status, NT_STATUS_CANNOT_DELETE)) {
768 printf("(%s) setting delete_on_close on open should "
769 "fail with NT_STATUS_CANNOT_DELETE. Got %s "
770 "instead)\n",
771 __location__, smbcli_errstr(cli1->tree));
772 return False;
773 }
774 }
775
776 printf("twelvth delete on close test succeeded.\n");
777 return True;
778 }
779
780 /* Test 13 ... */
781 static BOOL deltest13(struct smbcli_state *cli1, struct smbcli_state *cli2)
782 {
783 int fnum1 = -1;
784 int fnum2 = -1;
785 BOOL correct = True;
786
787 del_clean_area(cli1, cli2);
788
789 /* Test 13: Does resetting the delete on close flag affect a second
790 * fd? */
791
792 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
793 SEC_FILE_READ_DATA|
794 SEC_FILE_WRITE_DATA|
795 SEC_STD_DELETE,
796 FILE_ATTRIBUTE_NORMAL,
797 NTCREATEX_SHARE_ACCESS_READ|
798 NTCREATEX_SHARE_ACCESS_WRITE|
799 NTCREATEX_SHARE_ACCESS_DELETE,
800 NTCREATEX_DISP_OVERWRITE_IF,
801 0, 0);
802
803 if (fnum1 == -1) {
804 printf("(%s) open of %s failed (%s)\n",
805 __location__, fname, smbcli_errstr(cli1->tree));
806 correct = False;
807 goto fail;
808 }
809
810 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
811 SEC_FILE_READ_DATA|
812 SEC_FILE_WRITE_DATA|
813 SEC_STD_DELETE,
814 FILE_ATTRIBUTE_NORMAL,
815 NTCREATEX_SHARE_ACCESS_READ|
816 NTCREATEX_SHARE_ACCESS_WRITE|
817 NTCREATEX_SHARE_ACCESS_DELETE,
818 NTCREATEX_DISP_OPEN, 0, 0);
819
820 if (fnum2 == -1) {
821 printf("(%s) open of %s failed (%s)\n",
822 __location__, fname, smbcli_errstr(cli2->tree));
823 correct = False;
824 goto fail;
825 }
826
827 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli1->tree, fnum1,
828 True))) {
829 printf("(%s) setting delete_on_close on file failed !\n",
830 __location__);
831 correct = False;
832 goto fail;
833 }
834
835 correct &= check_delete_on_close(cli1, fnum1, fname, True, __location__);
836 correct &= check_delete_on_close(cli2, fnum2, fname, True, __location__);
837
838 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli2->tree, fnum2,
839 False))) {
840 printf("(%s) setting delete_on_close on file failed !\n",
841 __location__);
842 correct = False;
843 goto fail;
844 }
845
846 correct &= check_delete_on_close(cli1, fnum1, fname, False, __location__);
847 correct &= check_delete_on_close(cli2, fnum2, fname, False, __location__);
848
849 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
850 printf("(%s) close - 1 failed (%s)\n",
851 __location__, smbcli_errstr(cli1->tree));
852 correct = False;
853 goto fail;
854 }
855
856 if (NT_STATUS_IS_ERR(smbcli_close(cli2->tree, fnum2))) {
857 printf("(%s) close - 2 failed (%s)\n",
858 __location__, smbcli_errstr(cli2->tree));
859 correct = False;
860 goto fail;
861 }
862
863 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
864
865 if (fnum1 == -1) {
866 printf("(%s) open of %s failed!\n",
867 __location__, fname);
868 correct = False;
869 goto fail;
870 }
871
872 printf("thirteenth delete on close test succeeded.\n");
873
874 fail:
875
876 return correct;
877 }
878
879 /* Test 14 ... */
880 static BOOL deltest14(struct smbcli_state *cli1, struct smbcli_state *cli2)
881 {
882 int dnum1 = -1;
883 BOOL correct = True;
884
885 del_clean_area(cli1, cli2);
886
887 /* Test 14 -- directory */
888
889 dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
890 SEC_FILE_READ_DATA|
891 SEC_FILE_WRITE_DATA|
892 SEC_STD_DELETE,
893 FILE_ATTRIBUTE_DIRECTORY,
894 NTCREATEX_SHARE_ACCESS_READ|
895 NTCREATEX_SHARE_ACCESS_WRITE|
896 NTCREATEX_SHARE_ACCESS_DELETE,
897 NTCREATEX_DISP_CREATE, 0, 0);
898 if (dnum1 == -1) {
899 printf("(%s) open of %s failed: %s!\n",
900 __location__, dname, smbcli_errstr(cli1->tree));
901 correct = False;
902 goto fail;
903 }
904
905 correct &= check_delete_on_close(cli1, dnum1, dname, False, __location__);
906 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli1->tree, dnum1, True))) {
907 printf("(%s) setting delete_on_close on file failed !\n",
908 __location__);
909 correct = False;
910 goto fail;
911 }
912 correct &= check_delete_on_close(cli1, dnum1, dname, True, __location__);
913 smbcli_close(cli1->tree, dnum1);
914
915 /* Now it should be gone... */
916
917 dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
918 SEC_FILE_READ_DATA|
919 SEC_FILE_WRITE_DATA|
920 SEC_STD_DELETE,
921 FILE_ATTRIBUTE_DIRECTORY,
922 NTCREATEX_SHARE_ACCESS_READ|
923 NTCREATEX_SHARE_ACCESS_WRITE|
924 NTCREATEX_SHARE_ACCESS_DELETE,
925 NTCREATEX_DISP_OPEN, 0, 0);
926 if (dnum1 != -1) {
927 printf("(%s) setting delete_on_close on file succeeded !\n",
928 __location__);
929 correct = False;
930 goto fail;
931 }
932
933 printf("fourteenth delete on close test succeeded.\n");
934
935 fail:
936
937 return correct;
938 }
939
940 /* Test 15 ... */
941 static BOOL deltest15(struct smbcli_state *cli1, struct smbcli_state *cli2)
942 {
943 int fnum1 = -1;
944 int fnum2 = -1;
945 BOOL correct = True;
946 NTSTATUS status;
947
948 del_clean_area(cli1, cli2);
949
950 /* Test 15: delete on close under rename */
951
952 smbcli_setatr(cli1->tree, fname, 0, 0);
953 smbcli_unlink(cli1->tree, fname);
954 smbcli_unlink(cli1->tree, fname_new);
955
956 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
957 SEC_FILE_READ_DATA,
958 FILE_ATTRIBUTE_NORMAL,
959 NTCREATEX_SHARE_ACCESS_READ|
960 NTCREATEX_SHARE_ACCESS_WRITE|
961 NTCREATEX_SHARE_ACCESS_DELETE,
962 NTCREATEX_DISP_OVERWRITE_IF,
963 0, 0);
964
965 if (fnum1 == -1) {
966 printf("(%s) open - 1 of %s failed (%s)\n",
967 __location__, fname, smbcli_errstr(cli1->tree));
968 correct = False;
969 goto fail;
970 }
971
972 status = smbcli_rename(cli2->tree, fname, fname_new);
973
974 if (!NT_STATUS_IS_OK(status)) {
975 printf("(%s) renaming failed: %s !\n",
976 __location__, nt_errstr(status));
977 correct = False;
978 goto fail;
979 }
980
981 fnum2 = smbcli_nt_create_full(cli2->tree, fname_new, 0,
982 SEC_GENERIC_ALL,
983 FILE_ATTRIBUTE_NORMAL,
984 NTCREATEX_SHARE_ACCESS_READ|
985 NTCREATEX_SHARE_ACCESS_WRITE|
986 NTCREATEX_SHARE_ACCESS_DELETE,
987 NTCREATEX_DISP_OVERWRITE_IF,
988 0, 0);
989
990 if (fnum2 == -1) {
991 printf("(%s) open - 1 of %s failed (%s)\n",
992 __location__, fname_new, smbcli_errstr(cli1->tree));
993 correct = False;
994 goto fail;
995 }
996
997 status = smbcli_nt_delete_on_close(cli2->tree, fnum2, True);
998
999 if (!NT_STATUS_IS_OK(status)) {
1000 printf("(%s) setting delete_on_close on file failed !\n",
1001 __location__);
1002 correct = False;
1003 goto fail;
1004 }
1005
1006 smbcli_close(cli2->tree, fnum2);
1007
1008 /* The file should be around under the new name, there's a second
1009 * handle open */
1010
1011 correct &= check_delete_on_close(cli1, fnum1, fname_new, True, __location__);
1012
1013 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
1014 SEC_GENERIC_ALL,
1015 FILE_ATTRIBUTE_NORMAL,
1016 NTCREATEX_SHARE_ACCESS_READ|
1017 NTCREATEX_SHARE_ACCESS_WRITE|
1018 NTCREATEX_SHARE_ACCESS_DELETE,
1019 NTCREATEX_DISP_OVERWRITE_IF,
1020 0, 0);
1021
1022 if (fnum2 == -1) {
1023 printf("(%s) open - 1 of %s failed (%s)\n",
1024 __location__, fname, smbcli_errstr(cli1->tree));
1025 correct = False;
1026 goto fail;
1027 }
1028
1029 correct &= check_delete_on_close(cli2, fnum2, fname, False, __location__);
1030
1031 smbcli_close(cli2->tree, fnum2);
1032 smbcli_close(cli1->tree, fnum1);
1033
1034 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1035 SEC_FILE_READ_EA,
1036 FILE_ATTRIBUTE_NORMAL,
1037 NTCREATEX_SHARE_ACCESS_READ|
1038 NTCREATEX_SHARE_ACCESS_WRITE|
1039 NTCREATEX_SHARE_ACCESS_DELETE,
1040 NTCREATEX_DISP_OPEN,
1041 0, 0);
1042
1043 if (fnum1 == -1) {
1044 printf("(%s) open - 1 of %s failed (%s)\n",
1045 __location__, fname, smbcli_errstr(cli1->tree));
1046 correct = False;
1047 goto fail;
1048 }
1049
1050 smbcli_close(cli1->tree, fnum1);
1051
1052 fnum1 = smbcli_nt_create_full(cli1->tree, fname_new, 0,
1053 SEC_FILE_READ_EA,
1054 FILE_ATTRIBUTE_NORMAL,
1055 NTCREATEX_SHARE_ACCESS_READ|
1056 NTCREATEX_SHARE_ACCESS_WRITE|
1057 NTCREATEX_SHARE_ACCESS_DELETE,
1058 NTCREATEX_DISP_OPEN,
1059 0, 0);
1060
1061 if (fnum1 != -1) {
1062 printf("(%s) smbcli_open succeeded, should have "
1063 "failed\n", __location__);
1064 smbcli_close(cli1->tree, fnum1);
1065 correct = False;
1066 goto fail;
1067 }
1068
1069 printf("fifteenth delete on close test succeeded.\n");
1070
1071 fail:
1072
1073 return correct;
1074 }
1075
1076 /* Test 16 ... */
1077 static BOOL deltest16(struct smbcli_state *cli1, struct smbcli_state *cli2)
1078 {
1079 int fnum1 = -1;
1080 int fnum2 = -1;
1081 BOOL correct = True;
1082
1083 del_clean_area(cli1, cli2);
1084
1085 /* Test 16. */
1086
1087 /* Ensure the file doesn't already exist. */
1088 smbcli_close(cli1->tree, fnum1);
1089 smbcli_close(cli1->tree, fnum2);
1090 smbcli_setatr(cli1->tree, fname, 0, 0);
1091 smbcli_unlink(cli1->tree, fname);
1092
1093 /* Firstly create with all access, but delete on close. */
1094 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1095 SEC_RIGHTS_FILE_ALL,
1096 FILE_ATTRIBUTE_NORMAL,
1097 NTCREATEX_SHARE_ACCESS_READ|
1098 NTCREATEX_SHARE_ACCESS_WRITE|
1099 NTCREATEX_SHARE_ACCESS_DELETE,
1100 NTCREATEX_DISP_CREATE,
1101 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1102
1103 if (fnum1 == -1) {
1104 printf("(%s) open - 1 of %s failed (%s)\n",
1105 __location__, fname, smbcli_errstr(cli1->tree));
1106 correct = False;
1107 goto fail;
1108 }
1109
1110 /* The delete on close bit is *not* reported as being set. */
1111 correct &= check_delete_on_close(cli1, fnum1, fname, False, __location__);
1112
1113 /* The delete on close bit is *not* reported as being set. */
1114 correct &= check_delete_on_close(cli1, -1, fname, False, __location__);
1115 correct &= check_delete_on_close(cli2, -1, fname, False, __location__);
1116
1117 /* Now try opening again for read-only. */
1118 fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
1119 SEC_RIGHTS_FILE_READ,
1120 FILE_ATTRIBUTE_NORMAL,
1121 NTCREATEX_SHARE_ACCESS_READ|
1122 NTCREATEX_SHARE_ACCESS_WRITE|
1123 NTCREATEX_SHARE_ACCESS_DELETE,
1124 NTCREATEX_DISP_OPEN,
1125 0, 0);
1126
1127
1128 /* Should work. */
1129 if (fnum2 == -1) {
1130 printf("(%s) open - 1 of %s failed (%s)\n",
1131 __location__, fname, smbcli_errstr(cli1->tree));
1132 correct = False;
1133 goto fail;
1134 }
1135
1136 correct &= check_delete_on_close(cli1, fnum1, fname, False, __location__);
1137 correct &= check_delete_on_close(cli1, -1, fname, False, __location__);
1138 correct &= check_delete_on_close(cli2, fnum2, fname, False, __location__);
1139 correct &= check_delete_on_close(cli2, -1, fname, False, __location__);
1140
1141 smbcli_close(cli1->tree, fnum1);
1142
1143 correct &= check_delete_on_close(cli2, fnum2, fname, True, __location__);
1144 correct &= check_delete_on_close(cli2, -1, fname, True, __location__);
1145
1146 smbcli_close(cli2->tree, fnum2);
1147
1148 /* And the file should be deleted ! */
1149 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1150 if (fnum1 != -1) {
1151 printf("(%s) open of %s succeeded (should fail)\n",
1152 __location__, fname);
1153 correct = False;
1154 goto fail;
1155 }
1156
1157 printf("sixteenth delete on close test succeeded.\n");
1158
1159 fail:
1160
1161 return correct;
1162 }
1163
1164 /* Test 17 ... */
1165 static BOOL deltest17(struct smbcli_state *cli1, struct smbcli_state *cli2)
1166 {
1167 int fnum1 = -1;
1168 int fnum2 = -1;
1169 BOOL correct = True;
1170
1171 del_clean_area(cli1, cli2);
1172
1173 /* Test 17. */
1174
1175 /* Ensure the file doesn't already exist. */
1176 smbcli_close(cli1->tree, fnum1);
1177 smbcli_close(cli1->tree, fnum2);
1178 smbcli_setatr(cli1->tree, fname, 0, 0);
1179 smbcli_unlink(cli1->tree, fname);
1180
1181 /* Firstly open and create with all access */
1182 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1183 SEC_RIGHTS_FILE_ALL,
1184 FILE_ATTRIBUTE_NORMAL,
1185 NTCREATEX_SHARE_ACCESS_READ|
1186 NTCREATEX_SHARE_ACCESS_WRITE|
1187 NTCREATEX_SHARE_ACCESS_DELETE,
1188 NTCREATEX_DISP_CREATE,
1189 0, 0);
1190 if (fnum1 == -1) {
1191 printf("(%s) open - 1 of %s failed (%s)\n",
1192 __location__, fname, smbcli_errstr(cli1->tree));
1193 correct = False;
1194 goto fail;
1195 }
1196
1197 /* And close - just to create the file. */
1198 smbcli_close(cli1->tree, fnum1);
1199
1200 /* Next open with all access, but add delete on close. */
1201 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1202 SEC_RIGHTS_FILE_ALL,
1203 FILE_ATTRIBUTE_NORMAL,
1204 NTCREATEX_SHARE_ACCESS_READ|
1205 NTCREATEX_SHARE_ACCESS_WRITE|
1206 NTCREATEX_SHARE_ACCESS_DELETE,
1207 NTCREATEX_DISP_OPEN,
1208 NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1209
1210 if (fnum1 == -1) {
1211 printf("(%s) open - 1 of %s failed (%s)\n",
1212 __location__, fname, smbcli_errstr(cli1->tree));
1213 correct = False;
1214 goto fail;
1215 }
1216
1217 /* The delete on close bit is *not* reported as being set. */
1218 correct &= check_delete_on_close(cli1, fnum1, fname, False, __location__);
1219
1220 /* Now try opening again for read-only. */
1221 fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
1222 SEC_RIGHTS_FILE_READ|
1223 SEC_STD_DELETE,
1224 FILE_ATTRIBUTE_NORMAL,
1225 NTCREATEX_SHARE_ACCESS_READ|
1226 NTCREATEX_SHARE_ACCESS_WRITE|
1227 NTCREATEX_SHARE_ACCESS_DELETE,
1228 NTCREATEX_DISP_OPEN,
1229 0, 0);
1230
1231 /* Should work. */
1232 if (fnum2 == -1) {
1233 printf("(%s) open - 1 of %s failed (%s)\n",
1234 __location__, fname, smbcli_errstr(cli1->tree));
1235 correct = False;
1236 goto fail;
1237 }
1238
1239 /* still not reported as being set on either */
1240 correct &= check_delete_on_close(cli1, fnum1, fname, False, __location__);
1241 correct &= check_delete_on_close(cli1, fnum2, fname, False, __location__);
1242
1243 smbcli_close(cli1->tree, fnum1);
1244
1245 correct &= check_delete_on_close(cli1, fnum2, fname, False, __location__);
1246
1247 smbcli_close(cli1->tree, fnum2);
1248
1249 /* See if the file is deleted - shouldn't be.... */
1250 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1251 if (fnum1 == -1) {
1252 printf("(%s) open of %s failed (should succeed) - %s\n",
1253 __location__, fname, smbcli_errstr(cli1->tree));
1254 correct = False;
1255 goto fail;
1256 }
1257
1258 printf("seventeenth delete on close test succeeded.\n");
1259
1260 fail:
1261
1262 return correct;
1263 }
1264
1265 /* Test 18 ... */
1266 static BOOL deltest18(struct smbcli_state *cli1, struct smbcli_state *cli2)
1267 {
1268 int fnum1 = -1;
1269 int fnum2 = -1;
1270 BOOL correct = True;
1271
1272 del_clean_area(cli1, cli2);
1273
1274 /* Test 18. With directories. */
1275
1276 /* Ensure the file doesn't already exist. */
1277 smbcli_close(cli1->tree, fnum1);
1278 smbcli_close(cli1->tree, fnum2);
1279
1280 smbcli_deltree(cli1->tree, dname);
1281
1282 /* Firstly create with all access, but delete on close. */
1283 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1284 SEC_FILE_READ_DATA|
1285 SEC_FILE_WRITE_DATA|
1286 SEC_STD_DELETE,
1287 FILE_ATTRIBUTE_DIRECTORY,
1288 NTCREATEX_SHARE_ACCESS_READ|
1289 NTCREATEX_SHARE_ACCESS_WRITE|
1290 NTCREATEX_SHARE_ACCESS_DELETE,
1291 NTCREATEX_DISP_CREATE,
1292 NTCREATEX_OPTIONS_DIRECTORY|NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1293
1294 if (fnum1 == -1) {
1295 printf("(%s) open - 1 of %s failed (%s)\n",
1296 __location__, dname, smbcli_errstr(cli1->tree));
1297 correct = False;
1298 goto fail;
1299 }
1300
1301 /* The delete on close bit is *not* reported as being set. */
1302 correct &= check_delete_on_close(cli1, fnum1, dname, False, __location__);
1303
1304 /* Now try opening again for read-only. */
1305 fnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
1306 SEC_RIGHTS_FILE_READ,
1307 FILE_ATTRIBUTE_DIRECTORY,
1308 NTCREATEX_SHARE_ACCESS_READ|
1309 NTCREATEX_SHARE_ACCESS_WRITE|
1310 NTCREATEX_SHARE_ACCESS_DELETE,
1311 NTCREATEX_DISP_OPEN,
1312 NTCREATEX_OPTIONS_DIRECTORY, 0);
1313
1314
1315 /* Should work. */
1316 if (fnum2 == -1) {
1317 printf("(%s) open - 1 of %s failed (%s)\n",
1318 __location__, dname, smbcli_errstr(cli1->tree));
1319 correct = False;
1320 goto fail;
1321 }
1322
1323 correct &= check_delete_on_close(cli1, fnum1, dname, False, __location__);
1324 correct &= check_delete_on_close(cli1, fnum2, dname, False, __location__);
1325
1326 smbcli_close(cli1->tree, fnum1);
1327
1328 correct &= check_delete_on_close(cli1, fnum2, dname, True, __location__);
1329
1330 smbcli_close(cli1->tree, fnum2);
1331
1332 /* And the directory should be deleted ! */
1333 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1334 SEC_RIGHTS_FILE_READ,
1335 FILE_ATTRIBUTE_DIRECTORY,
1336 NTCREATEX_SHARE_ACCESS_READ|
1337 NTCREATEX_SHARE_ACCESS_WRITE|
1338 NTCREATEX_SHARE_ACCESS_DELETE,
1339 NTCREATEX_DISP_OPEN,
1340 NTCREATEX_OPTIONS_DIRECTORY, 0);
1341 if (fnum1 != -1) {
1342 printf("(%s) open of %s succeeded (should fail)\n",
1343 __location__, dname);
1344 correct = False;
1345 goto fail;
1346 }
1347
1348 printf("eighteenth delete on close test succeeded.\n");
1349
1350 fail:
1351
1352 return correct;
1353 }
1354
1355 /* Test 19 ... */
1356 static BOOL deltest19(struct smbcli_state *cli1, struct smbcli_state *cli2)
1357 {
1358 int fnum1 = -1;
1359 int fnum2 = -1;
1360 BOOL correct = True;
1361
1362 del_clean_area(cli1, cli2);
1363
1364 /* Test 19. */
1365
1366 smbcli_deltree(cli1->tree, dname);
1367
1368 /* Firstly open and create with all access */
1369 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1370 SEC_FILE_READ_DATA|
1371 SEC_FILE_WRITE_DATA|
1372 SEC_STD_DELETE,
1373 FILE_ATTRIBUTE_DIRECTORY,
1374 NTCREATEX_SHARE_ACCESS_READ|
1375 NTCREATEX_SHARE_ACCESS_WRITE|
1376 NTCREATEX_SHARE_ACCESS_DELETE,
1377 NTCREATEX_DISP_CREATE,
1378 NTCREATEX_OPTIONS_DIRECTORY, 0);
1379
1380 if (fnum1 == -1) {
1381 printf("(%s) open - 1 of %s failed (%s)\n",
1382 __location__, dname, smbcli_errstr(cli1->tree));
1383 correct = False;
1384 goto fail;
1385 }
1386
1387 /* And close - just to create the directory. */
1388 smbcli_close(cli1->tree, fnum1);
1389
1390 /* Next open with all access, but add delete on close. */
1391 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1392 SEC_FILE_READ_DATA|
1393 SEC_FILE_WRITE_DATA|
1394 SEC_STD_DELETE,
1395 FILE_ATTRIBUTE_DIRECTORY,
1396 NTCREATEX_SHARE_ACCESS_READ|
1397 NTCREATEX_SHARE_ACCESS_WRITE|
1398 NTCREATEX_SHARE_ACCESS_DELETE,
1399 NTCREATEX_DISP_OPEN,
1400 NTCREATEX_OPTIONS_DIRECTORY|NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1401
1402 if (fnum1 == -1) {
1403 printf("(%s) open - 1 of %s failed (%s)\n",
1404 __location__, fname, smbcli_errstr(cli1->tree));
1405 correct = False;
1406 goto fail;
1407 }
1408
1409 /* The delete on close bit is *not* reported as being set. */
1410 correct &= check_delete_on_close(cli1, fnum1, dname, False, __location__);
1411
1412 /* Now try opening again for read-only. */
1413 fnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
1414 SEC_RIGHTS_FILE_READ,
1415 FILE_ATTRIBUTE_DIRECTORY,
1416 NTCREATEX_SHARE_ACCESS_READ|
1417 NTCREATEX_SHARE_ACCESS_WRITE|
1418 NTCREATEX_SHARE_ACCESS_DELETE,
1419 NTCREATEX_DISP_OPEN,
1420 NTCREATEX_OPTIONS_DIRECTORY, 0);
1421
1422 /* Should work. */
1423 if (fnum2 == -1) {
1424 printf("(%s) open - 1 of %s failed (%s)\n",
1425 __location__, dname, smbcli_errstr(cli1->tree));
1426 correct = False;
1427 goto fail;
1428 }
1429
1430 smbcli_close(cli1->tree, fnum1);
1431
1432 correct &= check_delete_on_close(cli1, fnum2, dname, True, __location__);
1433
1434 smbcli_close(cli1->tree, fnum2);
1435
1436 /* See if the file is deleted - for a directory this seems to be true ! */
1437 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1438 SEC_RIGHTS_FILE_READ,
1439 FILE_ATTRIBUTE_DIRECTORY,
1440 NTCREATEX_SHARE_ACCESS_READ|
1441 NTCREATEX_SHARE_ACCESS_WRITE|
1442 NTCREATEX_SHARE_ACCESS_DELETE,
1443 NTCREATEX_DISP_OPEN,
1444 NTCREATEX_OPTIONS_DIRECTORY, 0);
1445
1446 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1447
1448 if (fnum1 != -1) {
1449 printf("(%s) open of %s succeeded (should fail)\n",
1450 __location__, dname);
1451 correct = False;
1452 goto fail;
1453 }
1454
1455 printf("nineteenth delete on close test succeeded.\n");
1456
1457 fail:
1458
1459 return correct;
1460 }
1461
1462 /* Test 20 ... */
1463 static BOOL deltest20(struct smbcli_state *cli1, struct smbcli_state *cli2)
1464 {
1465 int fnum1 = -1;
1466 int dnum1 = -1;
1467 BOOL correct = True;
1468 NTSTATUS status;
1469
1470 del_clean_area(cli1, cli2);
1471
1472 /* Test 20 -- non-empty directory hardest to get right... */
1473
1474 smbcli_deltree(cli1->tree, dname);
1475
1476 dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1477 SEC_FILE_READ_DATA|
1478 SEC_FILE_WRITE_DATA|
1479 SEC_STD_DELETE,
1480 FILE_ATTRIBUTE_DIRECTORY,
1481 NTCREATEX_SHARE_ACCESS_READ|
1482 NTCREATEX_SHARE_ACCESS_WRITE|
1483 NTCREATEX_SHARE_ACCESS_DELETE,
1484 NTCREATEX_DISP_CREATE,
1485 NTCREATEX_OPTIONS_DIRECTORY, 0);
1486 if (dnum1 == -1) {
1487 printf("(%s) open of %s failed: %s!\n",
1488 __location__, dname, smbcli_errstr(cli1->tree));
1489 correct = False;
1490 goto fail;
1491 }
1492
1493 correct &= check_delete_on_close(cli1, dnum1, dname, False, __location__);
1494 status = smbcli_nt_delete_on_close(cli1->tree, dnum1, True);
1495
1496 {
1497 char *fullname;
1498 asprintf(&fullname, "\\%s%s", dname, fname);
1499 fnum1 = smbcli_open(cli1->tree, fullname, O_CREAT|O_RDWR,
1500 DENY_NONE);
1501 if (fnum1 != -1) {
1502 printf("(%s) smbcli_open succeeded, should have "
1503 "failed with NT_STATUS_DELETE_PENDING\n",
1504 __location__);
1505 correct = False;
1506 goto fail;
1507 }
1508
1509 if (!NT_STATUS_EQUAL(smbcli_nt_error(cli1->tree),
1510 NT_STATUS_DELETE_PENDING)) {
1511 printf("(%s) smbcli_open returned %s, expected "
1512 "NT_STATUS_DELETE_PENDING\n",
1513 __location__, smbcli_errstr(cli1->tree));
1514 correct = False;
1515 goto fail;
1516 }
1517 }
1518
1519 status = smbcli_nt_delete_on_close(cli1->tree, dnum1, False);
1520 if (!NT_STATUS_IS_OK(status)) {
1521 printf("(%s) setting delete_on_close on file failed !\n",
1522 __location__);
1523 correct = False;
1524 goto fail;
1525 }
1526
1527 {
1528 char *fullname;
1529 asprintf(&fullname, "\\%s%s", dname, fname);
1530 fnum1 = smbcli_open(cli1->tree, fullname, O_CREAT|O_RDWR,
1531 DENY_NONE);
1532 if (fnum1 == -1) {
1533 printf("(%s) smbcli_open failed: %s\n",
1534 __location__, smbcli_errstr(cli1->tree));
1535 correct = False;
1536 goto fail;
1537 }
1538 smbcli_close(cli1->tree, fnum1);
1539 }
1540
1541 status = smbcli_nt_delete_on_close(cli1->tree, dnum1, True);
1542
1543 if (!NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
1544 printf("(%s) setting delete_on_close returned %s, expected "
1545 "NT_STATUS_DIRECTORY_NOT_EMPTY\n", __location__,
1546 smbcli_errstr(cli1->tree));
1547 correct = False;
1548 goto fail;
1549 }
1550
1551 smbcli_close(cli1->tree, dnum1);
1552
1553 printf("twentieth delete on close test succeeded.\n");
1554
1555 fail:
1556
1557 return correct;
1558 }
1559
1560 /* Test 21 ... */
1561 static BOOL deltest21(struct smbcli_state **ppcli1, struct smbcli_state **ppcli2)
1562 {
1563 int fnum1 = -1;
1564 struct smbcli_state *cli1 = *ppcli1;
1565 struct smbcli_state *cli2 = *ppcli2;
1566 BOOL correct = True;
1567
1568 del_clean_area(cli1, cli2);
1569
1570 /* Test 21 -- Test removal of file after socket close. */
1571
1572 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1573 SEC_RIGHTS_FILE_ALL,
1574 FILE_ATTRIBUTE_NORMAL, NTCREATEX_SHARE_ACCESS_NONE,
1575 NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
1576
1577 if (fnum1 == -1) {
1578 printf("(%s) open of %s failed (%s)\n",
1579 __location__, fname, smbcli_errstr(cli1->tree));
1580 return False;
1581 }
1582
1583 if (NT_STATUS_IS_ERR(smbcli_nt_delete_on_close(cli1->tree, fnum1, True))) {
1584 printf("(%s) setting delete_on_close failed (%s)\n",
1585 __location__, smbcli_errstr(cli1->tree));
1586 return False;
1587 }
1588
1589 /* Ensure delete on close is set. */
1590 correct &= check_delete_on_close(cli1, fnum1, fname, True, __location__);
1591
1592 /* Now yank the rug from under cli1. */
1593 smbcli_transport_dead(cli1->transport);
1594
1595 fnum1 = -1;
1596
1597 if (!torture_open_connection(ppcli1)) {
1598 return False;
1599 }
1600
1601 cli1 = *ppcli1;
1602
1603 /* File should not be there. */
1604 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1605 SEC_RIGHTS_FILE_READ,
1606 FILE_ATTRIBUTE_NORMAL,
1607 NTCREATEX_SHARE_ACCESS_READ|
1608 NTCREATEX_SHARE_ACCESS_WRITE|
1609 NTCREATEX_SHARE_ACCESS_DELETE,
1610 NTCREATEX_DISP_OPEN,
1611 0, 0);
1612
1613 CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1614
1615 printf("twenty-first delete on close test succeeded.\n");
1616
1617 fail:
1618
1619 return correct;
1620 }
1621
1622 /*
1623 Test delete on close semantics.
1624 */
1625 BOOL torture_test_delete(struct torture_context *torture)
1626 {
1627 struct smbcli_state *cli1 = NULL;
1628 struct smbcli_state *cli2 = NULL;
1629 BOOL correct = True;
1630
1631 printf("starting delete test\n");
1632
1633 if (!torture_open_connection(&cli1)) {
1634 return False;
1635 }
1636
1637 if (!torture_open_connection(&cli2)) {
1638 printf("(%s) failed to open second connection.\n",
1639 __location__);
1640 correct = False;
1641 goto fail;
1642 }
1643
1644 correct &= deltest1(cli1, cli2);
1645 correct &= deltest2(cli1, cli2);
1646 correct &= deltest3(cli1, cli2);
1647 correct &= deltest4(cli1, cli2);
1648 correct &= deltest5(cli1, cli2);
1649 correct &= deltest6(cli1, cli2);
1650 correct &= deltest7(cli1, cli2);
1651 correct &= deltest8(cli1, cli2);
1652 correct &= deltest9(cli1, cli2);
1653 correct &= deltest10(cli1, cli2);
1654 correct &= deltest11(cli1, cli2);
1655 correct &= deltest12(cli1, cli2);
1656 correct &= deltest13(cli1, cli2);
1657 correct &= deltest14(cli1, cli2);
1658 correct &= deltest15(cli1, cli2);
1659 if (!lp_parm_bool(-1, "target", "samba3", False)) {
1660 correct &= deltest16(cli1, cli2);
1661 correct &= deltest17(cli1, cli2);
1662 correct &= deltest18(cli1, cli2);
1663 correct &= deltest19(cli1, cli2);
1664 correct &= deltest20(cli1, cli2);
1665 }
1666 correct &= deltest21(&cli1, &cli2);
1667
1668 if (!correct) {
1669 printf("Failed delete test\n");
1670 } else {
1671 printf("delete test ok !\n");
1672 }
1673
1674 fail:
1675 del_clean_area(cli1, cli2);
1676
1677 if (!torture_close_connection(cli1)) {
1678 correct = False;
1679 }
1680 if (!torture_close_connection(cli2)) {
1681 correct = False;
1682 }
1683 return correct;
1684 }
Samba GIT mirror