Debian Codegraph @

source4/torture/raw/samba3misc.c

raw
1 /*
2 Unix SMB/CIFS implementation.
3 Test some misc Samba3 code paths
4 Copyright (C) Volker Lendecke 2006
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "torture/torture.h"
22 #include "libcli/raw/libcliraw.h"
23 #include "libcli/raw/raw_proto.h"
24 #include "system/time.h"
25 #include "system/filesys.h"
26 #include "libcli/libcli.h"
27 #include "torture/util.h"
28 #include "lib/events/events.h"
29 #include "param/param.h"
30 #include "torture/raw/proto.h"
31
32 /*
33 The next 2 functions are stolen from source4/libcli/raw/rawfile.c
34 but allow us to send a raw data blob instead of an OpenX name.
35 */
36
37 #define SETUP_REQUEST(cmd, wct, buflen) do { \
38 req = smbcli_request_setup(tree, cmd, wct, buflen); \
39 if (!req) return NULL; \
40 } while (0)
41
42 static struct smbcli_request *smb_raw_openX_name_blob_send(struct smbcli_tree *tree,
43 union smb_open *parms,
44 const DATA_BLOB *pname_blob)
45 {
46 struct smbcli_request *req = NULL;
47
48 if (parms->generic.level != RAW_OPEN_OPENX) {
49 return NULL;
50 }
51
52 SETUP_REQUEST(SMBopenX, 15, 0);
53 SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
54 SSVAL(req->out.vwv, VWV(1), 0);
55 SSVAL(req->out.vwv, VWV(2), parms->openx.in.flags);
56 SSVAL(req->out.vwv, VWV(3), parms->openx.in.open_mode);
57 SSVAL(req->out.vwv, VWV(4), parms->openx.in.search_attrs);
58 SSVAL(req->out.vwv, VWV(5), parms->openx.in.file_attrs);
59 raw_push_dos_date3(tree->session->transport,
60 req->out.vwv, VWV(6), parms->openx.in.write_time);
61 SSVAL(req->out.vwv, VWV(8), parms->openx.in.open_func);
62 SIVAL(req->out.vwv, VWV(9), parms->openx.in.size);
63 SIVAL(req->out.vwv, VWV(11),parms->openx.in.timeout);
64 SIVAL(req->out.vwv, VWV(13),0); /* reserved */
65 smbcli_req_append_blob(req, pname_blob);
66
67 if (!smbcli_request_send(req)) {
68 smbcli_request_destroy(req);
69 return NULL;
70 }
71
72 return req;
73 }
74
75 static NTSTATUS smb_raw_openX_name_blob(struct smbcli_tree *tree,
76 TALLOC_CTX *mem_ctx,
77 union smb_open *parms,
78 const DATA_BLOB *pname_blob)
79 {
80 struct smbcli_request *req = smb_raw_openX_name_blob_send(tree, parms, pname_blob);
81 return smb_raw_open_recv(req, mem_ctx, parms);
82 }
83
84 static NTSTATUS raw_smbcli_openX_name_blob(struct smbcli_tree *tree,
85 const DATA_BLOB *pname_blob,
86 int flags,
87 int share_mode,
88 int *fnum)
89 {
90 union smb_open open_parms;
91 unsigned int openfn=0;
92 unsigned int accessmode=0;
93 TALLOC_CTX *mem_ctx;
94 NTSTATUS status;
95
96 mem_ctx = talloc_init("raw_openX_name_blob");
97 if (!mem_ctx) return NT_STATUS_NO_MEMORY;
98
99 if (flags & O_CREAT) {
100 openfn |= OPENX_OPEN_FUNC_CREATE;
101 }
102 if (!(flags & O_EXCL)) {
103 if (flags & O_TRUNC) {
104 openfn |= OPENX_OPEN_FUNC_TRUNC;
105 } else {
106 openfn |= OPENX_OPEN_FUNC_OPEN;
107 }
108 }
109
110 accessmode = (share_mode<<OPENX_MODE_DENY_SHIFT);
111
112 if ((flags & O_ACCMODE) == O_RDWR) {
113 accessmode |= OPENX_MODE_ACCESS_RDWR;
114 } else if ((flags & O_ACCMODE) == O_WRONLY) {
115 accessmode |= OPENX_MODE_ACCESS_WRITE;
116 } else if ((flags & O_ACCMODE) == O_RDONLY) {
117 accessmode |= OPENX_MODE_ACCESS_READ;
118 }
119
120 #if defined(O_SYNC)
121 if ((flags & O_SYNC) == O_SYNC) {
122 accessmode |= OPENX_MODE_WRITE_THRU;
123 }
124 #endif
125
126 if (share_mode == DENY_FCB) {
127 accessmode = OPENX_MODE_ACCESS_FCB | OPENX_MODE_DENY_FCB;
128 }
129
130 open_parms.openx.level = RAW_OPEN_OPENX;
131 open_parms.openx.in.flags = 0;
132 open_parms.openx.in.open_mode = accessmode;
133 open_parms.openx.in.search_attrs = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
134 open_parms.openx.in.file_attrs = 0;
135 open_parms.openx.in.write_time = 0;
136 open_parms.openx.in.open_func = openfn;
137 open_parms.openx.in.size = 0;
138 open_parms.openx.in.timeout = 0;
139 open_parms.openx.in.fname = NULL;
140
141 status = smb_raw_openX_name_blob(tree, mem_ctx, &open_parms, pname_blob);
142 talloc_free(mem_ctx);
143
144 if (fnum && NT_STATUS_IS_OK(status)) {
145 *fnum = open_parms.openx.out.file.fnum;
146 }
147
148 return status;
149 }
150
151
152 #define CHECK_STATUS(torture, status, correct) do { \
153 if (!NT_STATUS_EQUAL(status, correct)) { \
154 torture_result(torture, TORTURE_FAIL, "%s: Incorrect status %s - should be %s\n", \
155 __location__, nt_errstr(status), nt_errstr(correct)); \
156 ret = false; \
157 } \
158 } while (0)
159
160 bool torture_samba3_checkfsp(struct torture_context *torture, struct smbcli_state *cli)
161 {
162 const char *fname = "test.txt";
163 const char *dirname = "testdir";
164 int fnum;
165 NTSTATUS status;
166 bool ret = true;
167 TALLOC_CTX *mem_ctx;
168 ssize_t nread;
169 char buf[16];
170 struct smbcli_tree *tree2;
171
172 torture_assert(torture, mem_ctx = talloc_init("torture_samba3_checkfsp"), "talloc_init failed\n");
173
174 torture_assert_ntstatus_equal(torture, torture_second_tcon(torture, cli->session,
175 torture_setting_string(torture, "share", NULL),
176 &tree2),
177 NT_STATUS_OK,
178 "creating second tcon");
179
180 /* Try a read on an invalid FID */
181
182 nread = smbcli_read(cli->tree, 4711, buf, 0, sizeof(buf));
183 CHECK_STATUS(torture, smbcli_nt_error(cli->tree), NT_STATUS_INVALID_HANDLE);
184
185 /* Try a read on a directory handle */
186
187 torture_assert(torture, torture_setup_dir(cli, dirname), "creating test directory");
188
189 /* Open the directory */
190 {
191 union smb_open io;
192 io.generic.level = RAW_OPEN_NTCREATEX;
193 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
194 io.ntcreatex.in.root_fid.fnum = 0;
195 io.ntcreatex.in.security_flags = 0;
196 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
197 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
198 io.ntcreatex.in.alloc_size = 0;
199 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
200 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
201 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
202 io.ntcreatex.in.create_options = 0;
203 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
204 io.ntcreatex.in.fname = dirname;
205 status = smb_raw_open(cli->tree, mem_ctx, &io);
206 if (!NT_STATUS_IS_OK(status)) {
207 torture_result(torture, TORTURE_FAIL, "smb_open on the directory failed: %s\n",
208 nt_errstr(status));
209 ret = false;
210 goto done;
211 }
212 fnum = io.ntcreatex.out.file.fnum;
213 }
214
215 /* Try a read on the directory */
216
217 nread = smbcli_read(cli->tree, fnum, buf, 0, sizeof(buf));
218 if (nread >= 0) {
219 torture_result(torture, TORTURE_FAIL, "smbcli_read on a directory succeeded, expected "
220 "failure\n");
221 ret = false;
222 }
223
224 CHECK_STATUS(torture, smbcli_nt_error(cli->tree),
225 NT_STATUS_INVALID_DEVICE_REQUEST);
226
227 /* Same test on the second tcon */
228
229 nread = smbcli_read(tree2, fnum, buf, 0, sizeof(buf));
230 if (nread >= 0) {
231 torture_result(torture, TORTURE_FAIL, "smbcli_read on a directory succeeded, expected "
232 "failure\n");
233 ret = false;
234 }
235
236 CHECK_STATUS(torture, smbcli_nt_error(tree2), NT_STATUS_INVALID_HANDLE);
237
238 smbcli_close(cli->tree, fnum);
239
240 /* Try a normal file read on a second tcon */
241
242 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
243 if (fnum == -1) {
244 torture_result(torture, TORTURE_FAIL, "Failed to create %s - %s\n", fname,
245 smbcli_errstr(cli->tree));
246 ret = false;
247 goto done;
248 }
249
250 nread = smbcli_read(tree2, fnum, buf, 0, sizeof(buf));
251 CHECK_STATUS(torture, smbcli_nt_error(tree2), NT_STATUS_INVALID_HANDLE);
252
253 smbcli_close(cli->tree, fnum);
254
255 done:
256 smbcli_deltree(cli->tree, dirname);
257 talloc_free(mem_ctx);
258
259 return ret;
260 }
261
262 static NTSTATUS raw_smbcli_open(struct smbcli_tree *tree, const char *fname, int flags, int share_mode, int *fnum)
263 {
264 union smb_open open_parms;
265 unsigned int openfn=0;
266 unsigned int accessmode=0;
267 TALLOC_CTX *mem_ctx;
268 NTSTATUS status;
269
270 mem_ctx = talloc_init("raw_open");
271 if (!mem_ctx) return NT_STATUS_NO_MEMORY;
272
273 if (flags & O_CREAT) {
274 openfn |= OPENX_OPEN_FUNC_CREATE;
275 }
276 if (!(flags & O_EXCL)) {
277 if (flags & O_TRUNC) {
278 openfn |= OPENX_OPEN_FUNC_TRUNC;
279 } else {
280 openfn |= OPENX_OPEN_FUNC_OPEN;
281 }
282 }
283
284 accessmode = (share_mode<<OPENX_MODE_DENY_SHIFT);
285
286 if ((flags & O_ACCMODE) == O_RDWR) {
287 accessmode |= OPENX_MODE_ACCESS_RDWR;
288 } else if ((flags & O_ACCMODE) == O_WRONLY) {
289 accessmode |= OPENX_MODE_ACCESS_WRITE;
290 } else if ((flags & O_ACCMODE) == O_RDONLY) {
291 accessmode |= OPENX_MODE_ACCESS_READ;
292 }
293
294 #if defined(O_SYNC)
295 if ((flags & O_SYNC) == O_SYNC) {
296 accessmode |= OPENX_MODE_WRITE_THRU;
297 }
298 #endif
299
300 if (share_mode == DENY_FCB) {
301 accessmode = OPENX_MODE_ACCESS_FCB | OPENX_MODE_DENY_FCB;
302 }
303
304 open_parms.openx.level = RAW_OPEN_OPENX;
305 open_parms.openx.in.flags = 0;
306 open_parms.openx.in.open_mode = accessmode;
307 open_parms.openx.in.search_attrs = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
308 open_parms.openx.in.file_attrs = 0;
309 open_parms.openx.in.write_time = 0;
310 open_parms.openx.in.open_func = openfn;
311 open_parms.openx.in.size = 0;
312 open_parms.openx.in.timeout = 0;
313 open_parms.openx.in.fname = fname;
314
315 status = smb_raw_open(tree, mem_ctx, &open_parms);
316 talloc_free(mem_ctx);
317
318 if (fnum && NT_STATUS_IS_OK(status)) {
319 *fnum = open_parms.openx.out.file.fnum;
320 }
321
322 return status;
323 }
324
325 static NTSTATUS raw_smbcli_t2open(struct smbcli_tree *tree, const char *fname, int flags, int share_mode, int *fnum)
326 {
327 union smb_open io;
328 unsigned int openfn=0;
329 unsigned int accessmode=0;
330 TALLOC_CTX *mem_ctx;
331 NTSTATUS status;
332
333 mem_ctx = talloc_init("raw_t2open");
334 if (!mem_ctx) return NT_STATUS_NO_MEMORY;
335
336 if (flags & O_CREAT) {
337 openfn |= OPENX_OPEN_FUNC_CREATE;
338 }
339 if (!(flags & O_EXCL)) {
340 if (flags & O_TRUNC) {
341 openfn |= OPENX_OPEN_FUNC_TRUNC;
342 } else {
343 openfn |= OPENX_OPEN_FUNC_OPEN;
344 }
345 }
346
347 accessmode = (share_mode<<OPENX_MODE_DENY_SHIFT);
348
349 if ((flags & O_ACCMODE) == O_RDWR) {
350 accessmode |= OPENX_MODE_ACCESS_RDWR;
351 } else if ((flags & O_ACCMODE) == O_WRONLY) {
352 accessmode |= OPENX_MODE_ACCESS_WRITE;
353 } else if ((flags & O_ACCMODE) == O_RDONLY) {
354 accessmode |= OPENX_MODE_ACCESS_READ;
355 }
356
357 #if defined(O_SYNC)
358 if ((flags & O_SYNC) == O_SYNC) {
359 accessmode |= OPENX_MODE_WRITE_THRU;
360 }
361 #endif
362
363 if (share_mode == DENY_FCB) {
364 accessmode = OPENX_MODE_ACCESS_FCB | OPENX_MODE_DENY_FCB;
365 }
366
367 memset(&io, '\0', sizeof(io));
368 io.t2open.level = RAW_OPEN_T2OPEN;
369 io.t2open.in.flags = 0;
370 io.t2open.in.open_mode = accessmode;
371 io.t2open.in.search_attrs = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
372 io.t2open.in.file_attrs = 0;
373 io.t2open.in.write_time = 0;
374 io.t2open.in.open_func = openfn;
375 io.t2open.in.size = 0;
376 io.t2open.in.timeout = 0;
377 io.t2open.in.fname = fname;
378
379 io.t2open.in.num_eas = 1;
380 io.t2open.in.eas = talloc_array(mem_ctx, struct ea_struct, io.t2open.in.num_eas);
381 io.t2open.in.eas[0].flags = 0;
382 io.t2open.in.eas[0].name.s = ".CLASSINFO";
383 io.t2open.in.eas[0].value = data_blob_talloc(mem_ctx, "first value", 11);
384
385 status = smb_raw_open(tree, mem_ctx, &io);
386 talloc_free(mem_ctx);
387
388 if (fnum && NT_STATUS_IS_OK(status)) {
389 *fnum = io.openx.out.file.fnum;
390 }
391
392 return status;
393 }
394
395 static NTSTATUS raw_smbcli_ntcreate(struct smbcli_tree *tree, const char *fname, int *fnum)
396 {
397 union smb_open io;
398 TALLOC_CTX *mem_ctx;
399 NTSTATUS status;
400
401 mem_ctx = talloc_init("raw_t2open");
402 if (!mem_ctx) return NT_STATUS_NO_MEMORY;
403
404 memset(&io, '\0', sizeof(io));
405 io.generic.level = RAW_OPEN_NTCREATEX;
406 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
407 io.ntcreatex.in.root_fid.fnum = 0;
408 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
409 io.ntcreatex.in.alloc_size = 0;
410 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
411 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
412 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
413 io.ntcreatex.in.create_options = 0;
414 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
415 io.ntcreatex.in.security_flags = 0;
416 io.ntcreatex.in.fname = fname;
417
418 status = smb_raw_open(tree, mem_ctx, &io);
419 talloc_free(mem_ctx);
420
421 if (fnum && NT_STATUS_IS_OK(status)) {
422 *fnum = io.openx.out.file.fnum;
423 }
424
425 return status;
426 }
427
428
429 bool torture_samba3_badpath(struct torture_context *torture)
430 {
431 struct smbcli_state *cli_nt = NULL;
432 struct smbcli_state *cli_dos = NULL;
433 const char *fname = "test.txt";
434 const char *fname1 = "test1.txt";
435 const char *dirname = "testdir";
436 char *fpath;
437 char *fpath1;
438 int fnum;
439 NTSTATUS status;
440 bool ret = true;
441 TALLOC_CTX *mem_ctx;
442 bool nt_status_support;
443 bool client_ntlmv2_auth;
444
445 torture_assert(torture, mem_ctx = talloc_init("torture_samba3_badpath"), "talloc_init failed");
446
447 nt_status_support = lpcfg_nt_status_support(torture->lp_ctx);
448 client_ntlmv2_auth = lpcfg_client_ntlmv2_auth(torture->lp_ctx);
449
450 torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "nt status support", "yes"), ret, fail, "Could not set 'nt status support = yes'\n");
451 torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "client ntlmv2 auth", "yes"), ret, fail, "Could not set 'client ntlmv2 auth = yes'\n");
452
453 torture_assert_goto(torture, torture_open_connection(&cli_nt, torture, 0), ret, fail, "Could not open NTSTATUS connection\n");
454
455 torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "nt status support", "no"), ret, fail, "Could not set 'nt status support = no'\n");
456 torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "client ntlmv2 auth", "no"), ret, fail, "Could not set 'client ntlmv2 auth = no'\n");
457
458 torture_assert_goto(torture, torture_open_connection(&cli_dos, torture, 1), ret, fail, "Could not open DOS connection\n");
459
460 torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "nt status support",
461 nt_status_support ? "yes":"no"),
462 ret, fail, "Could not set 'nt status support' back to where it was\n");
463 torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "client ntlmv2 auth",
464 client_ntlmv2_auth ? "yes":"no"),
465 ret, fail, "Could not set 'client ntlmv2 auth' back to where it was\n");
466
467 torture_assert(torture, torture_setup_dir(cli_nt, dirname), "creating test directory");
468
469 status = smbcli_chkpath(cli_nt->tree, dirname);
470 CHECK_STATUS(torture, status, NT_STATUS_OK);
471
472 status = smbcli_chkpath(cli_nt->tree,
473 talloc_asprintf(mem_ctx, "%s\\bla", dirname));
474 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
475
476 status = smbcli_chkpath(cli_dos->tree,
477 talloc_asprintf(mem_ctx, "%s\\bla", dirname));
478 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRbadpath));
479
480 status = smbcli_chkpath(cli_nt->tree,
481 talloc_asprintf(mem_ctx, "%s\\bla\\blub",
482 dirname));
483 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_PATH_NOT_FOUND);
484 status = smbcli_chkpath(cli_dos->tree,
485 talloc_asprintf(mem_ctx, "%s\\bla\\blub",
486 dirname));
487 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRbadpath));
488
489 torture_assert_goto(torture, fpath = talloc_asprintf(mem_ctx, "%s\\%s", dirname, fname),
490 ret, fail, "Could not allocate fpath\n");
491
492 fnum = smbcli_open(cli_nt->tree, fpath, O_RDWR | O_CREAT, DENY_NONE);
493 if (fnum == -1) {
494 torture_result(torture, TORTURE_FAIL, "Could not create file %s: %s\n", fpath,
495 smbcli_errstr(cli_nt->tree));
496 goto fail;
497 }
498 smbcli_close(cli_nt->tree, fnum);
499
500 if (!(fpath1 = talloc_asprintf(mem_ctx, "%s\\%s", dirname, fname1))) {
501 goto fail;
502 }
503 fnum = smbcli_open(cli_nt->tree, fpath1, O_RDWR | O_CREAT, DENY_NONE);
504 if (fnum == -1) {
505 torture_result(torture, TORTURE_FAIL, "Could not create file %s: %s\n", fpath1,
506 smbcli_errstr(cli_nt->tree));
507 goto fail;
508 }
509 smbcli_close(cli_nt->tree, fnum);
510
511 /*
512 * Do a whole bunch of error code checks on chkpath
513 */
514
515 status = smbcli_chkpath(cli_nt->tree, fpath);
516 CHECK_STATUS(torture, status, NT_STATUS_NOT_A_DIRECTORY);
517 status = smbcli_chkpath(cli_dos->tree, fpath);
518 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRbadpath));
519
520 status = smbcli_chkpath(cli_nt->tree, "..");
521 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD);
522 status = smbcli_chkpath(cli_dos->tree, "..");
523 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidpath));
524
525 status = smbcli_chkpath(cli_nt->tree, ".");
526 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
527 status = smbcli_chkpath(cli_dos->tree, ".");
528 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRbadpath));
529
530 status = smbcli_chkpath(cli_nt->tree, "\t");
531 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
532 status = smbcli_chkpath(cli_dos->tree, "\t");
533 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRbadpath));
534
535 status = smbcli_chkpath(cli_nt->tree, "\t\\bla");
536 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
537 status = smbcli_chkpath(cli_dos->tree, "\t\\bla");
538 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRbadpath));
539
540 status = smbcli_chkpath(cli_nt->tree, "<");
541 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
542 status = smbcli_chkpath(cli_dos->tree, "<");
543 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRbadpath));
544
545 status = smbcli_chkpath(cli_nt->tree, "<\\bla");
546 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
547 status = smbcli_chkpath(cli_dos->tree, "<\\bla");
548 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRbadpath));
549
550 /*
551 * .... And the same gang against getatr. Note that the DOS error codes
552 * differ....
553 */
554
555 status = smbcli_getatr(cli_nt->tree, fpath, NULL, NULL, NULL);
556 CHECK_STATUS(torture, status, NT_STATUS_OK);
557 status = smbcli_getatr(cli_dos->tree, fpath, NULL, NULL, NULL);
558 CHECK_STATUS(torture, status, NT_STATUS_OK);
559
560 status = smbcli_getatr(cli_nt->tree, "..", NULL, NULL, NULL);
561 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD);
562 status = smbcli_getatr(cli_dos->tree, "..", NULL, NULL, NULL);
563 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidpath));
564
565 status = smbcli_getatr(cli_nt->tree, ".", NULL, NULL, NULL);
566 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
567 status = smbcli_getatr(cli_dos->tree, ".", NULL, NULL, NULL);
568 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
569
570 status = smbcli_getatr(cli_nt->tree, "\t", NULL, NULL, NULL);
571 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
572 status = smbcli_getatr(cli_dos->tree, "\t", NULL, NULL, NULL);
573 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
574
575 status = smbcli_getatr(cli_nt->tree, "\t\\bla", NULL, NULL, NULL);
576 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
577 status = smbcli_getatr(cli_dos->tree, "\t\\bla", NULL, NULL, NULL);
578 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
579
580 status = smbcli_getatr(cli_nt->tree, "<", NULL, NULL, NULL);
581 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
582 status = smbcli_getatr(cli_dos->tree, "<", NULL, NULL, NULL);
583 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
584
585 status = smbcli_getatr(cli_nt->tree, "<\\bla", NULL, NULL, NULL);
586 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
587 status = smbcli_getatr(cli_dos->tree, "<\\bla", NULL, NULL, NULL);
588 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
589
590 /* Try the same set with openX. */
591
592 status = raw_smbcli_open(cli_nt->tree, "..", O_RDONLY, DENY_NONE, NULL);
593 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD);
594 status = raw_smbcli_open(cli_dos->tree, "..", O_RDONLY, DENY_NONE, NULL);
595 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidpath));
596
597 status = raw_smbcli_open(cli_nt->tree, ".", O_RDONLY, DENY_NONE, NULL);
598 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
599 status = raw_smbcli_open(cli_dos->tree, ".", O_RDONLY, DENY_NONE, NULL);
600 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
601
602 status = raw_smbcli_open(cli_nt->tree, "\t", O_RDONLY, DENY_NONE, NULL);
603 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
604 status = raw_smbcli_open(cli_dos->tree, "\t", O_RDONLY, DENY_NONE, NULL);
605 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
606
607 status = raw_smbcli_open(cli_nt->tree, "\t\\bla", O_RDONLY, DENY_NONE, NULL);
608 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
609 status = raw_smbcli_open(cli_dos->tree, "\t\\bla", O_RDONLY, DENY_NONE, NULL);
610 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
611
612 status = raw_smbcli_open(cli_nt->tree, "<", O_RDONLY, DENY_NONE, NULL);
613 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
614 status = raw_smbcli_open(cli_dos->tree, "<", O_RDONLY, DENY_NONE, NULL);
615 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
616
617 status = raw_smbcli_open(cli_nt->tree, "<\\bla", O_RDONLY, DENY_NONE, NULL);
618 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_INVALID);
619 status = raw_smbcli_open(cli_dos->tree, "<\\bla", O_RDONLY, DENY_NONE, NULL);
620 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS, ERRinvalidname));
621
622 /* Let's test EEXIST error code mapping. */
623 status = raw_smbcli_open(cli_nt->tree, fpath, O_RDONLY | O_CREAT| O_EXCL, DENY_NONE, NULL);
624 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_COLLISION);
625 status = raw_smbcli_open(cli_dos->tree, fpath, O_RDONLY | O_CREAT| O_EXCL, DENY_NONE, NULL);
626 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS,ERRfilexists));
627
628 status = raw_smbcli_t2open(cli_nt->tree, fpath, O_RDONLY | O_CREAT| O_EXCL, DENY_NONE, NULL);
629 if (!NT_STATUS_EQUAL(status, NT_STATUS_EAS_NOT_SUPPORTED)
630 || !torture_setting_bool(torture, "samba3", false)) {
631 /* Against samba3, treat EAS_NOT_SUPPORTED as acceptable */
632 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_COLLISION);
633 }
634 status = raw_smbcli_t2open(cli_dos->tree, fpath, O_RDONLY | O_CREAT| O_EXCL, DENY_NONE, NULL);
635 if (!NT_STATUS_EQUAL(status, NT_STATUS_DOS(ERRDOS,ERReasnotsupported))
636 || !torture_setting_bool(torture, "samba3", false)) {
637 /* Against samba3, treat EAS_NOT_SUPPORTED as acceptable */
638 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS,ERRfilexists));
639 }
640
641 status = raw_smbcli_ntcreate(cli_nt->tree, fpath, NULL);
642 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_COLLISION);
643 status = raw_smbcli_ntcreate(cli_dos->tree, fpath, NULL);
644 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS,ERRfilexists));
645
646 /* Try the rename test. */
647 {
648 union smb_rename io;
649 memset(&io, '\0', sizeof(io));
650 io.rename.in.pattern1 = fpath1;
651 io.rename.in.pattern2 = fpath;
652
653 /* Try with SMBmv rename. */
654 status = smb_raw_rename(cli_nt->tree, &io);
655 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_COLLISION);
656 status = smb_raw_rename(cli_dos->tree, &io);
657 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS,ERRrename));
658
659 /* Try with NT rename. */
660 io.generic.level = RAW_RENAME_NTRENAME;
661 io.ntrename.in.old_name = fpath1;
662 io.ntrename.in.new_name = fpath;
663 io.ntrename.in.attrib = 0;
664 io.ntrename.in.cluster_size = 0;
665 io.ntrename.in.flags = RENAME_FLAG_RENAME;
666
667 status = smb_raw_rename(cli_nt->tree, &io);
668 CHECK_STATUS(torture, status, NT_STATUS_OBJECT_NAME_COLLISION);
669 status = smb_raw_rename(cli_dos->tree, &io);
670 CHECK_STATUS(torture, status, NT_STATUS_DOS(ERRDOS,ERRrename));
671 }
672
673 goto done;
674
675 fail:
676 ret = false;
677
678 done:
679 if (cli_nt != NULL) {
680 smbcli_deltree(cli_nt->tree, dirname);
681 torture_close_connection(cli_nt);
682 }
683 if (cli_dos != NULL) {
684 torture_close_connection(cli_dos);
685 }
686 talloc_free(mem_ctx);
687
688 return ret;
689 }
690
691 static void count_fn(struct clilist_file_info *info, const char *name,
692 void *private_data)
693 {
694 int *counter = (int *)private_data;
695 *counter += 1;
696 }
697
698 bool torture_samba3_caseinsensitive(struct torture_context *torture, struct smbcli_state *cli)
699 {
700 TALLOC_CTX *mem_ctx;
701 const char *dirname = "insensitive";
702 const char *ucase_dirname = "InSeNsItIvE";
703 const char *fname = "foo";
704 char *fpath;
705 int fnum;
706 int counter = 0;
707 bool ret = false;
708
709 if (!(mem_ctx = talloc_init("torture_samba3_caseinsensitive"))) {
710 torture_result(torture, TORTURE_FAIL, "talloc_init failed\n");
711 return false;
712 }
713
714 torture_assert(torture, torture_setup_dir(cli, dirname), "creating test directory");
715
716 if (!(fpath = talloc_asprintf(mem_ctx, "%s\\%s", dirname, fname))) {
717 goto done;
718 }
719 fnum = smbcli_open(cli->tree, fpath, O_RDWR | O_CREAT, DENY_NONE);
720 if (fnum == -1) {
721 torture_result(torture, TORTURE_FAIL,
722 "Could not create file %s: %s", fpath,
723 smbcli_errstr(cli->tree));
724 goto done;
725 }
726 smbcli_close(cli->tree, fnum);
727
728 smbcli_list(cli->tree, talloc_asprintf(
729 mem_ctx, "%s\\*", ucase_dirname),
730 FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_HIDDEN
731 |FILE_ATTRIBUTE_SYSTEM,
732 count_fn, (void *)&counter);
733
734 if (counter == 3) {
735 ret = true;
736 }
737 else {
738 torture_result(torture, TORTURE_FAIL,
739 "expected 3 entries, got %d", counter);
740 ret = false;
741 }
742
743 done:
744 talloc_free(mem_ctx);
745 return ret;
746 }
747
748 static void close_locked_file(struct tevent_context *ev,
749 struct tevent_timer *te,
750 struct timeval now,
751 void *private_data)
752 {
753 int *pfd = (int *)private_data;
754
755 TALLOC_FREE(te);
756
757 if (*pfd != -1) {
758 close(*pfd);
759 *pfd = -1;
760 }
761 }
762
763 struct lock_result_state {
764 NTSTATUS status;
765 bool done;
766 };
767
768 static void receive_lock_result(struct smbcli_request *req)
769 {
770 struct lock_result_state *state =
771 (struct lock_result_state *)req->async.private_data;
772
773 state->status = smbcli_request_simple_recv(req);
774 state->done = true;
775 }
776
777 /*
778 * Check that Samba3 correctly deals with conflicting local posix byte range
779 * locks on an underlying file via "normal" SMB1 (without unix extensions).
780 *
781 * Note: This test depends on "posix locking = yes".
782 * Note: To run this test, use "--option=torture:localdir=<LOCALDIR>"
783 */
784
785 bool torture_samba3_posixtimedlock(struct torture_context *tctx, struct smbcli_state *cli)
786 {
787 NTSTATUS status;
788 bool ret = true;
789 const char *dirname = "posixlock";
790 const char *fname = "locked";
791 const char *fpath;
792 const char *localdir;
793 const char *localname;
794 int fnum = -1;
795
796 int fd = -1;
797 struct flock posix_lock;
798
799 union smb_lock io;
800 struct smb_lock_entry lock_entry;
801 struct smbcli_request *req;
802 struct lock_result_state lock_result;
803
804 struct tevent_timer *te;
805
806 torture_assert(tctx, torture_setup_dir(cli, dirname), "creating test directory");
807
808 if (!(fpath = talloc_asprintf(tctx, "%s\\%s", dirname, fname))) {
809 torture_warning(tctx, "talloc failed\n");
810 ret = false;
811 goto done;
812 }
813 fnum = smbcli_open(cli->tree, fpath, O_RDWR | O_CREAT, DENY_NONE);
814 if (fnum == -1) {
815 torture_warning(tctx, "Could not create file %s: %s\n", fpath,
816 smbcli_errstr(cli->tree));
817 ret = false;
818 goto done;
819 }
820
821 if (!(localdir = torture_setting_string(tctx, "localdir", NULL))) {
822 torture_warning(tctx, "Need 'localdir' setting\n");
823 ret = false;
824 goto done;
825 }
826
827 if (!(localname = talloc_asprintf(tctx, "%s/%s/%s", localdir, dirname,
828 fname))) {
829 torture_warning(tctx, "talloc failed\n");
830 ret = false;
831 goto done;
832 }
833
834 /*
835 * Lock a byte range from posix
836 */
837
838 fd = open(localname, O_RDWR);
839 if (fd == -1) {
840 torture_warning(tctx, "open(%s) failed: %s\n",
841 localname, strerror(errno));
842 goto done;
843 }
844
845 posix_lock.l_type = F_WRLCK;
846 posix_lock.l_whence = SEEK_SET;
847 posix_lock.l_start = 0;
848 posix_lock.l_len = 1;
849
850 if (fcntl(fd, F_SETLK, &posix_lock) == -1) {
851 torture_warning(tctx, "fcntl failed: %s\n", strerror(errno));
852 ret = false;
853 goto done;
854 }
855
856 /*
857 * Try a cifs brlock without timeout to see if posix locking = yes
858 */
859
860 io.lockx.in.ulock_cnt = 0;
861 io.lockx.in.lock_cnt = 1;
862
863 lock_entry.count = 1;
864 lock_entry.offset = 0;
865 lock_entry.pid = cli->tree->session->pid;
866
867 io.lockx.level = RAW_LOCK_LOCKX;
868 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
869 io.lockx.in.timeout = 0;
870 io.lockx.in.locks = &lock_entry;
871 io.lockx.in.file.fnum = fnum;
872
873 status = smb_raw_lock(cli->tree, &io);
874
875 ret = true;
876 CHECK_STATUS(tctx, status, NT_STATUS_LOCK_NOT_GRANTED);
877
878 if (!ret) {
879 goto done;
880 }
881
882 /*
883 * Now fire off a timed brlock, unlock the posix lock and see if the
884 * timed lock gets through.
885 */
886
887 io.lockx.in.timeout = 5000;
888
889 req = smb_raw_lock_send(cli->tree, &io);
890 if (req == NULL) {
891 torture_warning(tctx, "smb_raw_lock_send failed\n");
892 ret = false;
893 goto done;
894 }
895
896 lock_result.done = false;
897 req->async.fn = receive_lock_result;
898 req->async.private_data = &lock_result;
899
900 te = tevent_add_timer(tctx->ev,
901 tctx, timeval_current_ofs(1, 0),
902 close_locked_file, &fd);
903 if (te == NULL) {
904 torture_warning(tctx, "tevent_add_timer failed\n");
905 ret = false;
906 goto done;
907 }
908
909 while ((fd != -1) || (!lock_result.done)) {
910 if (tevent_loop_once(tctx->ev) == -1) {
911 torture_warning(tctx, "tevent_loop_once failed: %s\n",
912 strerror(errno));
913 ret = false;
914 goto done;
915 }
916 }
917
918 CHECK_STATUS(tctx, lock_result.status, NT_STATUS_OK);
919
920 done:
921 if (fnum != -1) {
922 smbcli_close(cli->tree, fnum);
923 }
924 if (fd != -1) {
925 close(fd);
926 }
927 smbcli_deltree(cli->tree, dirname);
928 return ret;
929 }
930
931 bool torture_samba3_rootdirfid(struct torture_context *tctx, struct smbcli_state *cli)
932 {
933 uint16_t dnum;
934 union smb_open io;
935 const char *fname = "testfile";
936 bool ret = false;
937
938 smbcli_unlink(cli->tree, fname);
939
940 ZERO_STRUCT(io);
941 io.generic.level = RAW_OPEN_NTCREATEX;
942 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
943 io.ntcreatex.in.root_fid.fnum = 0;
944 io.ntcreatex.in.security_flags = 0;
945 io.ntcreatex.in.access_mask =
946 SEC_STD_SYNCHRONIZE | SEC_FILE_EXECUTE;
947 io.ntcreatex.in.alloc_size = 0;
948 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
949 io.ntcreatex.in.share_access =
950 NTCREATEX_SHARE_ACCESS_READ
951 | NTCREATEX_SHARE_ACCESS_READ;
952 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
953 io.ntcreatex.in.create_options = 0;
954 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
955 io.ntcreatex.in.fname = "\\";
956 torture_assert_ntstatus_equal_goto(tctx, smb_raw_open(cli->tree, tctx, &io),
957 NT_STATUS_OK,
958 ret, done, "smb_open on the directory failed: %s\n");
959
960 dnum = io.ntcreatex.out.file.fnum;
961
962 io.ntcreatex.in.flags =
963 NTCREATEX_FLAGS_REQUEST_OPLOCK
964 | NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
965 io.ntcreatex.in.root_fid.fnum = dnum;
966 io.ntcreatex.in.security_flags = 0;
967 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
968 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
969 io.ntcreatex.in.alloc_size = 0;
970 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
971 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
972 io.ntcreatex.in.create_options = 0;
973 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
974 io.ntcreatex.in.fname = fname;
975
976 torture_assert_ntstatus_equal_goto(tctx, smb_raw_open(cli->tree, tctx, &io),
977 NT_STATUS_OK,
978 ret, done, "smb_open on the file failed");
979
980 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
981 smbcli_close(cli->tree, dnum);
982 smbcli_unlink(cli->tree, fname);
983
984 ret = true;
985 done:
986 return ret;
987 }
988
989 bool torture_samba3_rootdirfid2(struct torture_context *tctx, struct smbcli_state *cli)
990 {
991 int fnum;
992 uint16_t dnum;
993 union smb_open io;
994 const char *dirname1 = "dir1";
995 const char *dirname2 = "dir1/dir2";
996 const char *path = "dir1/dir2/testfile";
997 const char *relname = "dir2/testfile";
998 bool ret = false;
999
1000 smbcli_deltree(cli->tree, dirname1);
1001
1002 torture_assert(tctx, torture_setup_dir(cli, dirname1), "creating test directory");
1003 torture_assert(tctx, torture_setup_dir(cli, dirname2), "creating test directory");
1004
1005 fnum = smbcli_open(cli->tree, path, O_RDWR | O_CREAT, DENY_NONE);
1006 if (fnum == -1) {
1007 torture_result(tctx, TORTURE_FAIL,
1008 "Could not create file: %s",
1009 smbcli_errstr(cli->tree));
1010 goto done;
1011 }
1012 smbcli_close(cli->tree, fnum);
1013
1014 ZERO_STRUCT(io);
1015 io.generic.level = RAW_OPEN_NTCREATEX;
1016 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
1017 io.ntcreatex.in.root_fid.fnum = 0;
1018 io.ntcreatex.in.security_flags = 0;
1019 io.ntcreatex.in.access_mask =
1020 SEC_STD_SYNCHRONIZE | SEC_FILE_EXECUTE;
1021 io.ntcreatex.in.alloc_size = 0;
1022 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
1023 io.ntcreatex.in.share_access =
1024 NTCREATEX_SHARE_ACCESS_READ
1025 | NTCREATEX_SHARE_ACCESS_READ;
1026 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1027 io.ntcreatex.in.create_options = 0;
1028 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1029 io.ntcreatex.in.fname = dirname1;
1030 torture_assert_ntstatus_equal_goto(tctx, smb_raw_open(cli->tree, tctx, &io),
1031 NT_STATUS_OK,
1032 ret, done, "smb_open on the directory failed: %s\n");
1033
1034 dnum = io.ntcreatex.out.file.fnum;
1035
1036 io.ntcreatex.in.flags =
1037 NTCREATEX_FLAGS_REQUEST_OPLOCK
1038 | NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1039 io.ntcreatex.in.root_fid.fnum = dnum;
1040 io.ntcreatex.in.security_flags = 0;
1041 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1042 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1043 io.ntcreatex.in.alloc_size = 0;
1044 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1045 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1046 io.ntcreatex.in.create_options = 0;
1047 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1048 io.ntcreatex.in.fname = relname;
1049
1050 torture_assert_ntstatus_equal_goto(tctx, smb_raw_open(cli->tree, tctx, &io),
1051 NT_STATUS_OK,
1052 ret, done, "smb_open on the file failed");
1053
1054 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1055 smbcli_close(cli->tree, dnum);
1056
1057 ret = true;
1058 done:
1059 smbcli_deltree(cli->tree, dirname1);
1060 return ret;
1061 }
1062
1063 bool torture_samba3_oplock_logoff(struct torture_context *tctx, struct smbcli_state *cli)
1064 {
1065 union smb_open io;
1066 const char *fname = "testfile";
1067 bool ret = false;
1068 struct smbcli_request *req;
1069 struct smb_echo echo_req;
1070
1071 smbcli_unlink(cli->tree, fname);
1072
1073 ZERO_STRUCT(io);
1074 io.generic.level = RAW_OPEN_NTCREATEX;
1075 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
1076 io.ntcreatex.in.root_fid.fnum = 0;
1077 io.ntcreatex.in.security_flags = 0;
1078 io.ntcreatex.in.access_mask =
1079 SEC_STD_SYNCHRONIZE | SEC_FILE_EXECUTE;
1080 io.ntcreatex.in.alloc_size = 0;
1081 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1082 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1083 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1084 io.ntcreatex.in.create_options = 0;
1085 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1086 io.ntcreatex.in.fname = "testfile";
1087 torture_assert_ntstatus_equal_goto(tctx, smb_raw_open(cli->tree, tctx, &io),
1088 NT_STATUS_OK,
1089 ret, done, "first smb_open on the file failed");
1090
1091 /*
1092 * Create a conflicting open, causing the one-second delay
1093 */
1094
1095 torture_assert_goto(tctx, req = smb_raw_open_send(cli->tree, &io),
1096 ret, done, "smb_raw_open_send on the file failed");
1097
1098 /*
1099 * Pull the VUID from under that request. As of Nov 3, 2008 all Samba3
1100 * versions (3.0, 3.2 and master) would spin sending ERRinvuid errors
1101 * as long as the client is still connected.
1102 */
1103
1104 torture_assert_ntstatus_equal_goto(tctx, smb_raw_ulogoff(cli->session),
1105 NT_STATUS_OK,
1106 ret, done, "ulogoff failed failed");
1107
1108 echo_req.in.repeat_count = 1;
1109 echo_req.in.size = 1;
1110 echo_req.in.data = discard_const_p(uint8_t, "");
1111
1112 torture_assert_ntstatus_equal_goto(tctx, smb_raw_echo(cli->session->transport, &echo_req),
1113 NT_STATUS_OK,
1114 ret, done, "smb_raw_echo failed");
1115
1116 ret = true;
1117 done:
1118 return ret;
1119 }
1120
1121 bool torture_samba3_check_openX_badname(struct torture_context *tctx, struct smbcli_state *cli)
1122 {
1123 NTSTATUS status;
1124 bool ret = false;
1125 int fnum = -1;
1126 DATA_BLOB name_blob = data_blob_talloc(cli->tree, NULL, 65535);
1127
1128 if (name_blob.data == NULL) {
1129 return false;
1130 }
1131 memset(name_blob.data, 0xcc, 65535);
1132 status = raw_smbcli_openX_name_blob(cli->tree, &name_blob, O_RDWR, DENY_NONE, &fnum);
1133 CHECK_STATUS(tctx, status, NT_STATUS_OBJECT_NAME_INVALID);
1134 ret = true;
1135
1136 return ret;
1137 }