source: trunk/server/source4/torture/basic/attr.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 16.6 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3
4 openattr tester
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/security/secace.h"
27
28extern int torture_failures;
29
30#define CHECK_MAX_FAILURES(label) do { if (++failures >= torture_failures) goto label; } while (0)
31
32
33static const uint32_t open_attrs_table[] = {
34 FILE_ATTRIBUTE_NORMAL,
35 FILE_ATTRIBUTE_ARCHIVE,
36 FILE_ATTRIBUTE_READONLY,
37 FILE_ATTRIBUTE_HIDDEN,
38 FILE_ATTRIBUTE_SYSTEM,
39
40 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY,
41 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN,
42 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM,
43 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
44 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
45 FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
46
47 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN,
48 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM,
49 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM,
50 FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_SYSTEM,
51};
52
53struct trunc_open_results {
54 unsigned int num;
55 uint32_t init_attr;
56 uint32_t trunc_attr;
57 uint32_t result_attr;
58};
59
60static const struct trunc_open_results attr_results[] = {
61 { 0, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
62 { 1, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
63 { 2, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
64 { 16, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_ARCHIVE },
65 { 17, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_ARCHIVE },
66 { 18, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY },
67 { 51, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
68 { 54, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
69 { 56, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
70 { 68, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
71 { 71, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
72 { 73, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
73 { 99, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN,FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
74 { 102, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
75 { 104, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
76 { 116, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
77 { 119, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
78 { 121, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM },
79 { 170, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN },
80 { 173, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM },
81 { 227, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
82 { 230, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_HIDDEN },
83 { 232, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN },
84 { 244, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
85 { 247, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_SYSTEM },
86 { 249, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_SYSTEM }
87};
88
89
90bool torture_openattrtest(struct torture_context *tctx,
91 struct smbcli_state *cli1)
92{
93 const char *fname = "\\openattr.file";
94 int fnum1;
95 uint16_t attr;
96 unsigned int i, j, k, l;
97 int failures = 0;
98
99 for (k = 0, i = 0; i < sizeof(open_attrs_table)/sizeof(uint32_t); i++) {
100 smbcli_setatr(cli1->tree, fname, 0, 0);
101 smbcli_unlink(cli1->tree, fname);
102 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
103 SEC_FILE_WRITE_DATA,
104 open_attrs_table[i],
105 NTCREATEX_SHARE_ACCESS_NONE, NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
106
107 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open %d (1) of %s failed (%s)", i,
108 fname, smbcli_errstr(cli1->tree)));
109
110 torture_assert_ntstatus_ok(tctx,
111 smbcli_close(cli1->tree, fnum1),
112 talloc_asprintf(tctx, "close %d (1) of %s failed (%s)", i, fname,
113 smbcli_errstr(cli1->tree)));
114
115 for (j = 0; j < ARRAY_SIZE(open_attrs_table); j++) {
116 fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
117 SEC_FILE_READ_DATA|
118 SEC_FILE_WRITE_DATA,
119 open_attrs_table[j],
120 NTCREATEX_SHARE_ACCESS_NONE,
121 NTCREATEX_DISP_OVERWRITE, 0, 0);
122
123 if (fnum1 == -1) {
124 for (l = 0; l < ARRAY_SIZE(attr_results); l++) {
125 if (attr_results[l].num == k) {
126 torture_result(tctx, TORTURE_FAIL,
127 "[%d] trunc open 0x%x -> 0x%x of %s failed - should have succeeded !(%s)",
128 k, open_attrs_table[i],
129 open_attrs_table[j],
130 fname, smbcli_errstr(cli1->tree));
131 CHECK_MAX_FAILURES(error_exit);
132 }
133 }
134 torture_assert_ntstatus_equal(tctx,
135 smbcli_nt_error(cli1->tree), NT_STATUS_ACCESS_DENIED,
136 talloc_asprintf(tctx, "[%d] trunc open 0x%x -> 0x%x failed with wrong error code %s",
137 k, open_attrs_table[i], open_attrs_table[j],
138 smbcli_errstr(cli1->tree)));
139 CHECK_MAX_FAILURES(error_exit);
140#if 0
141 torture_comment(tctx, "[%d] trunc open 0x%x -> 0x%x failed\n", k, open_attrs_table[i], open_attrs_table[j]);
142#endif
143 k++;
144 continue;
145 }
146
147 torture_assert_ntstatus_ok(tctx,
148 smbcli_close(cli1->tree, fnum1),
149 talloc_asprintf(tctx, "close %d (2) of %s failed (%s)", j,
150 fname, smbcli_errstr(cli1->tree)));
151
152 torture_assert_ntstatus_ok(tctx,
153 smbcli_getatr(cli1->tree, fname, &attr, NULL, NULL),
154 talloc_asprintf(tctx, "getatr(2) failed (%s)", smbcli_errstr(cli1->tree)));
155
156#if 0
157 torture_comment(tctx, "[%d] getatr check [0x%x] trunc [0x%x] got attr 0x%x\n",
158 k, open_attrs_table[i], open_attrs_table[j], attr );
159#endif
160
161 for (l = 0; l < ARRAY_SIZE(attr_results); l++) {
162 if (attr_results[l].num == k) {
163 if (attr != attr_results[l].result_attr ||
164 open_attrs_table[i] != attr_results[l].init_attr ||
165 open_attrs_table[j] != attr_results[l].trunc_attr) {
166 torture_result(tctx, TORTURE_FAIL,
167 "[%d] getatr check failed. [0x%x] trunc [0x%x] got attr 0x%x, should be 0x%x",
168 k, open_attrs_table[i],
169 open_attrs_table[j],
170 (unsigned int)attr,
171 attr_results[l].result_attr);
172 CHECK_MAX_FAILURES(error_exit);
173 }
174 break;
175 }
176 }
177 k++;
178 }
179 }
180error_exit:
181 smbcli_setatr(cli1->tree, fname, 0, 0);
182 smbcli_unlink(cli1->tree, fname);
183
184 return true;
185}
186
187bool torture_winattrtest(struct torture_context *tctx,
188 struct smbcli_state *cli1)
189{
190 const char *fname = "\\winattr1.file";
191 const char *dname = "\\winattr1.dir";
192 int fnum1;
193 uint16_t attr;
194 uint16_t j;
195 uint32_t aceno;
196 int failures = 0;
197 union smb_fileinfo query, query_org;
198 NTSTATUS status;
199 struct security_descriptor *sd1, *sd2;
200
201
202 /* Test winattrs for file */
203 smbcli_unlink(cli1->tree, fname);
204
205 /* Open a file*/
206 fnum1 = smbcli_open(cli1->tree, fname, O_RDWR | O_CREAT | O_TRUNC,
207 DENY_NONE);
208 torture_assert(tctx, fnum1 != -1,
209 talloc_asprintf(tctx, "open(1) of %s failed (%s)\n",
210 fname, smbcli_errstr(cli1->tree)));
211
212
213 /* Get security descriptor and store it*/
214 query_org.generic.level = RAW_FILEINFO_SEC_DESC;
215 query_org.generic.in.file.fnum = fnum1;
216 status = smb_raw_fileinfo(cli1->tree, tctx, &query_org);
217 if(!NT_STATUS_IS_OK(status)){
218 torture_comment(tctx, "smb_raw_fileinfo(1) of %s failed (%s)\n",
219 fname, nt_errstr(status));
220 torture_assert_ntstatus_ok(tctx,
221 smbcli_close(cli1->tree, fnum1),
222 talloc_asprintf(tctx,
223 "close(1) of %s failed (%s)\n",
224 fname, smbcli_errstr(cli1->tree)));
225 CHECK_MAX_FAILURES(error_exit_file);
226 }
227 sd1 = query_org.query_secdesc.out.sd;
228
229 torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
230 talloc_asprintf(tctx, "close(1) of %s failed (%s)\n",
231 fname, smbcli_errstr(cli1->tree)));
232
233 /*Set and get attributes*/
234 for (j = 0; j < ARRAY_SIZE(open_attrs_table); j++) {
235 torture_assert_ntstatus_ok(tctx,
236 smbcli_setatr(cli1->tree, fname, open_attrs_table[j],0),
237 talloc_asprintf(tctx, "setatr(2) failed (%s)",
238 smbcli_errstr(cli1->tree)));
239
240 torture_assert_ntstatus_ok(tctx,
241 smbcli_getatr(cli1->tree, fname, &attr, NULL, NULL),
242 talloc_asprintf(tctx, "getatr(2) failed (%s)",
243 smbcli_errstr(cli1->tree)));
244
245 /* Check the result */
246 if((j == 0)&&(attr != FILE_ATTRIBUTE_ARCHIVE)){
247 torture_comment(tctx, "getatr check failed. \
248 Attr applied [0x%x], got attr [0x%x], \
249 should be [0x%x]",
250 open_attrs_table[j],
251 (uint16_t)attr,open_attrs_table[j +1]);
252 CHECK_MAX_FAILURES(error_exit_file);
253 }else{
254
255 if((j != 0) &&(attr != open_attrs_table[j])){
256 torture_comment(tctx, "getatr check failed. \
257 Attr applied [0x%x],got attr 0x%x, \
258 should be 0x%x ",
259 open_attrs_table[j], (uint16_t)attr,
260 open_attrs_table[j]);
261 CHECK_MAX_FAILURES(error_exit_file);
262 }
263
264 }
265
266 fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY | O_CREAT,
267 DENY_NONE);
268 torture_assert(tctx, fnum1 != -1,
269 talloc_asprintf(tctx, "open(2) of %s failed (%s)\n",
270 fname, smbcli_errstr(cli1->tree)));
271 /*Get security descriptor */
272 query.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
273 query.query_secdesc.in.file.fnum = fnum1;
274 status = smb_raw_fileinfo(cli1->tree, tctx, &query);
275 if(!NT_STATUS_IS_OK(status)){
276 torture_comment(tctx,
277 "smb_raw_fileinfo(2) of %s failed (%s)\n",
278 fname, nt_errstr(status));
279 torture_assert_ntstatus_ok(tctx,
280 smbcli_close(cli1->tree, fnum1),
281 talloc_asprintf(tctx,
282 "close(2) of %s failed (%s)\n",
283 fname, smbcli_errstr(cli1->tree)));
284 CHECK_MAX_FAILURES(error_exit_file);
285 }
286 sd2 = query.query_secdesc.out.sd;
287
288 torture_assert_ntstatus_ok(tctx,smbcli_close(cli1->tree,fnum1),
289 talloc_asprintf(tctx, "close(2) of %s failed (%s)\n",
290 fname, smbcli_errstr(cli1->tree)));
291
292 /*Compare security descriptors -- Must be same*/
293 for (aceno=0;(sd1->dacl&&aceno < sd1->dacl->num_aces);aceno++){
294 struct security_ace *ace1 = &sd1->dacl->aces[aceno];
295 struct security_ace *ace2 = &sd2->dacl->aces[aceno];
296
297 if(!sec_ace_equal(ace1,ace2)){
298 torture_comment(tctx,
299 "ACLs changed! Not expected!\n");
300 CHECK_MAX_FAILURES(error_exit_file);
301 }
302 }
303
304 torture_comment(tctx, "[%d] setattr = [0x%x] got attr 0x%x\n",
305 j, open_attrs_table[j], attr );
306
307 }
308
309error_exit_file:
310 smbcli_setatr(cli1->tree, fname, 0, 0);
311 smbcli_unlink(cli1->tree, fname);
312
313/* Check for Directory. */
314
315 smbcli_deltree(cli1->tree, dname);
316 smbcli_rmdir(cli1->tree,dname);
317
318 /* Open a directory */
319 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
320 SEC_RIGHTS_DIR_ALL,
321 FILE_ATTRIBUTE_DIRECTORY,
322 NTCREATEX_SHARE_ACCESS_NONE,
323 NTCREATEX_DISP_OPEN_IF,
324 NTCREATEX_OPTIONS_DIRECTORY, 0);
325 /*smbcli_mkdir(cli1->tree,dname);*/
326
327 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx,
328 "open (1) of %s failed (%s)",
329 dname, smbcli_errstr(cli1->tree)));
330
331
332 /* Get Security Descriptor */
333 query_org.generic.level = RAW_FILEINFO_SEC_DESC;
334 query_org.generic.in.file.fnum = fnum1;
335 status = smb_raw_fileinfo(cli1->tree, tctx, &query_org);
336 if(!NT_STATUS_IS_OK(status)){
337 torture_comment(tctx, "smb_raw_fileinfo(1) of %s failed (%s)\n",
338 dname, nt_errstr(status));
339 torture_assert_ntstatus_ok(tctx,
340 smbcli_close(cli1->tree, fnum1),
341 talloc_asprintf(tctx,
342 "close(1) of %s failed (%s)\n",
343 dname, smbcli_errstr(cli1->tree)));
344 CHECK_MAX_FAILURES(error_exit_dir);
345 }
346 sd1 = query_org.query_secdesc.out.sd;
347
348 torture_assert_ntstatus_ok(tctx,
349 smbcli_close(cli1->tree, fnum1),
350 talloc_asprintf(tctx,
351 "close (1) of %s failed (%s)", dname,
352 smbcli_errstr(cli1->tree)));
353
354 /* Set and get win attributes*/
355 for (j = 1; j < ARRAY_SIZE(open_attrs_table); j++) {
356
357 torture_assert_ntstatus_ok(tctx,
358 smbcli_setatr(cli1->tree, dname, open_attrs_table[j], 0),
359 talloc_asprintf(tctx, "setatr(2) failed (%s)",
360 smbcli_errstr(cli1->tree)));
361
362 torture_assert_ntstatus_ok(tctx,
363 smbcli_getatr(cli1->tree, dname, &attr, NULL, NULL),
364 talloc_asprintf(tctx, "getatr(2) failed (%s)",
365 smbcli_errstr(cli1->tree)));
366
367 torture_comment(tctx, "[%d] setatt = [0x%x] got attr 0x%x\n",
368 j, open_attrs_table[j], attr );
369
370 /* Check the result */
371 if(attr != (open_attrs_table[j]|FILE_ATTRIBUTE_DIRECTORY)){
372 torture_comment(tctx, "getatr check failed. set attr \
373 [0x%x], got attr 0x%x, should be 0x%x\n",
374 open_attrs_table[j],
375 (uint16_t)attr,
376 open_attrs_table[j]|FILE_ATTRIBUTE_DIRECTORY);
377 CHECK_MAX_FAILURES(error_exit_dir);
378 }
379
380 fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
381 SEC_RIGHTS_DIR_READ,
382 FILE_ATTRIBUTE_DIRECTORY,
383 NTCREATEX_SHARE_ACCESS_NONE,
384 NTCREATEX_DISP_OPEN,
385 0,0);
386
387 torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx,
388 "open (2) of %s failed (%s)",
389 dname, smbcli_errstr(cli1->tree)));
390 /* Get security descriptor */
391 query.generic.level = RAW_FILEINFO_SEC_DESC;
392 query.generic.in.file.fnum = fnum1;
393 status = smb_raw_fileinfo(cli1->tree, tctx, &query);
394 if(!NT_STATUS_IS_OK(status)){
395 torture_comment(tctx, "smb_raw_fileinfo(2) of %s failed\
396 (%s)\n", dname, nt_errstr(status));
397 torture_assert_ntstatus_ok(tctx,
398 smbcli_close(cli1->tree, fnum1),
399 talloc_asprintf(tctx,
400 "close (2) of %s failed (%s)", dname,
401 smbcli_errstr(cli1->tree)));
402 CHECK_MAX_FAILURES(error_exit_dir);
403 }
404 sd2 = query.query_secdesc.out.sd;
405 torture_assert_ntstatus_ok(tctx,
406 smbcli_close(cli1->tree, fnum1),
407 talloc_asprintf(tctx,
408 "close (2) of %s failed (%s)", dname,
409 smbcli_errstr(cli1->tree)));
410
411 /* Security descriptor must be same*/
412 for (aceno=0;(sd1->dacl&&aceno < sd1->dacl->num_aces);aceno++){
413 struct security_ace *ace1 = &sd1->dacl->aces[aceno];
414 struct security_ace *ace2 = &sd2->dacl->aces[aceno];
415
416 if(!sec_ace_equal(ace1,ace2)){
417 torture_comment(tctx,
418 "ACLs changed! Not expected!\n");
419 CHECK_MAX_FAILURES(error_exit_dir);
420 }
421 }
422
423 }
424error_exit_dir:
425 smbcli_deltree(cli1->tree, dname);
426 smbcli_rmdir(cli1->tree,dname);
427
428 if(failures)
429 return false;
430 return true;
431}
Note: See TracBrowser for help on using the repository browser.