?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lib/util: Build iov_buf library only when building samba
[Samba.git] / source4 / torture / raw / lock.c
blob71f4955264151ff8acc4056da1e99ffce42f2d91
1 /*
2 Unix SMB/CIFS implementation.
3 test suite for various lock operations
4 Copyright (C) Andrew Tridgell 2003
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "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 "libcli/composite/composite.h"
29 #include "libcli/smb_composite/smb_composite.h"
30 #include "lib/cmdline/popt_common.h"
31 #include "param/param.h"
32 #include "torture/raw/proto.h"
33
34 #define CHECK_STATUS(status, correct) do { \
35 if (!NT_STATUS_EQUAL(status, correct)) { \
36 torture_result(tctx, TORTURE_FAIL, \
37 "(%s) Incorrect status %s - should be %s\n", \
38 __location__, nt_errstr(status), nt_errstr(correct)); \
39 ret = false; \
40 goto done; \
41 }} while (0)
42
43 #define CHECK_STATUS_CONT(status, correct) do { \
44 if (!NT_STATUS_EQUAL(status, correct)) { \
45 torture_result(tctx, TORTURE_FAIL, \
46 "(%s) Incorrect status %s - should be %s\n", \
47 __location__, nt_errstr(status), nt_errstr(correct)); \
48 ret = false; \
49 }} while (0)
50
51 #define CHECK_STATUS_OR(status, correct1, correct2) do { \
52 if ((!NT_STATUS_EQUAL(status, correct1)) && \
53 (!NT_STATUS_EQUAL(status, correct2))) { \
54 torture_result(tctx, TORTURE_FAIL, \
55 "(%s) Incorrect status %s - should be %s or %s\n", \
56 __location__, nt_errstr(status), nt_errstr(correct1), \
57 nt_errstr(correct2)); \
58 ret = false; \
59 goto done; \
60 }} while (0)
61
62 #define CHECK_STATUS_OR_CONT(status, correct1, correct2) do { \
63 if ((!NT_STATUS_EQUAL(status, correct1)) && \
64 (!NT_STATUS_EQUAL(status, correct2))) { \
65 torture_result(tctx, TORTURE_FAIL, \
66 "(%s) Incorrect status %s - should be %s or %s\n", \
67 __location__, nt_errstr(status), nt_errstr(correct1), \
68 nt_errstr(correct2)); \
69 ret = false; \
70 }} while (0)
71 #define BASEDIR "\\testlock"
72
73 #define TARGET_IS_W2K8(_tctx) (torture_setting_bool(_tctx, "w2k8", false))
74 #define TARGET_IS_WIN7(_tctx) (torture_setting_bool(_tctx, "win7", false))
75 #define TARGET_IS_WINDOWS(_tctx) \
76 ((torture_setting_bool(_tctx, "w2k3", false)) || \
77 (torture_setting_bool(_tctx, "w2k8", false)) || \
78 (torture_setting_bool(_tctx, "win7", false)))
79 #define TARGET_IS_SAMBA3(_tctx) (torture_setting_bool(_tctx, "samba3", false))
80 #define TARGET_IS_SAMBA4(_tctx) (torture_setting_bool(_tctx, "samba4", false))
81
82 #define TARGET_SUPPORTS_INVALID_LOCK_RANGE(_tctx) \
83 (torture_setting_bool(_tctx, "invalid_lock_range_support", true))
84 #define TARGET_SUPPORTS_SMBEXIT(_tctx) \
85 (torture_setting_bool(_tctx, "smbexit_pdu_support", true))
86 #define TARGET_SUPPORTS_SMBLOCK(_tctx) \
87 (torture_setting_bool(_tctx, "smblock_pdu_support", true))
88 #define TARGET_SUPPORTS_OPENX_DENY_DOS(_tctx) \
89 (torture_setting_bool(_tctx, "openx_deny_dos_support", true))
90 #define TARGET_RETURNS_RANGE_NOT_LOCKED(_tctx) \
91 (torture_setting_bool(_tctx, "range_not_locked_on_file_close", true))
92 /*
93 test SMBlock and SMBunlock ops
94 */
95 static bool test_lock(struct torture_context *tctx, struct smbcli_state *cli)
96 {
97 union smb_lock io;
98 NTSTATUS status;
99 bool ret = true;
100 int fnum;
101 const char *fname = BASEDIR "\\test.txt";
102
103 if (!TARGET_SUPPORTS_SMBLOCK(tctx))
104 torture_skip(tctx, "Target does not support the SMBlock PDU");
105
106 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
107
108 torture_comment(tctx, "Testing RAW_LOCK_LOCK\n");
109 io.generic.level = RAW_LOCK_LOCK;
110
111 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
112 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
113 "Failed to create %s - %s\n",
114 fname, smbcli_errstr(cli->tree)));
115
116 torture_comment(tctx, "Trying 0/0 lock\n");
117 io.lock.level = RAW_LOCK_LOCK;
118 io.lock.in.file.fnum = fnum;
119 io.lock.in.count = 0;
120 io.lock.in.offset = 0;
121 status = smb_raw_lock(cli->tree, &io);
122 CHECK_STATUS(status, NT_STATUS_OK);
123 cli->session->pid++;
124 status = smb_raw_lock(cli->tree, &io);
125 CHECK_STATUS(status, NT_STATUS_OK);
126 cli->session->pid--;
127 io.lock.level = RAW_LOCK_UNLOCK;
128 status = smb_raw_lock(cli->tree, &io);
129 CHECK_STATUS(status, NT_STATUS_OK);
130
131 torture_comment(tctx, "Trying 0/1 lock\n");
132 io.lock.level = RAW_LOCK_LOCK;
133 io.lock.in.file.fnum = fnum;
134 io.lock.in.count = 1;
135 io.lock.in.offset = 0;
136 status = smb_raw_lock(cli->tree, &io);
137 CHECK_STATUS(status, NT_STATUS_OK);
138 cli->session->pid++;
139 status = smb_raw_lock(cli->tree, &io);
140 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
141 cli->session->pid--;
142 io.lock.level = RAW_LOCK_UNLOCK;
143 status = smb_raw_lock(cli->tree, &io);
144 CHECK_STATUS(status, NT_STATUS_OK);
145 io.lock.level = RAW_LOCK_UNLOCK;
146 status = smb_raw_lock(cli->tree, &io);
147 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
148
149 torture_comment(tctx, "Trying 0xEEFFFFFF lock\n");
150 io.lock.level = RAW_LOCK_LOCK;
151 io.lock.in.file.fnum = fnum;
152 io.lock.in.count = 4000;
153 io.lock.in.offset = 0xEEFFFFFF;
154 status = smb_raw_lock(cli->tree, &io);
155 CHECK_STATUS(status, NT_STATUS_OK);
156 cli->session->pid++;
157 status = smb_raw_lock(cli->tree, &io);
158 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
159 cli->session->pid--;
160 io.lock.level = RAW_LOCK_UNLOCK;
161 status = smb_raw_lock(cli->tree, &io);
162 CHECK_STATUS(status, NT_STATUS_OK);
163 io.lock.level = RAW_LOCK_UNLOCK;
164 status = smb_raw_lock(cli->tree, &io);
165 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
166
167 torture_comment(tctx, "Trying 0xEF000000 lock\n");
168 io.lock.level = RAW_LOCK_LOCK;
169 io.lock.in.file.fnum = fnum;
170 io.lock.in.count = 4000;
171 io.lock.in.offset = 0xEEFFFFFF;
172 status = smb_raw_lock(cli->tree, &io);
173 CHECK_STATUS(status, NT_STATUS_OK);
174 cli->session->pid++;
175 status = smb_raw_lock(cli->tree, &io);
176 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
177 cli->session->pid--;
178 io.lock.level = RAW_LOCK_UNLOCK;
179 status = smb_raw_lock(cli->tree, &io);
180 CHECK_STATUS(status, NT_STATUS_OK);
181 io.lock.level = RAW_LOCK_UNLOCK;
182 status = smb_raw_lock(cli->tree, &io);
183 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
184
185 torture_comment(tctx, "Trying max lock\n");
186 io.lock.level = RAW_LOCK_LOCK;
187 io.lock.in.file.fnum = fnum;
188 io.lock.in.count = 4000;
189 io.lock.in.offset = 0xEF000000;
190 status = smb_raw_lock(cli->tree, &io);
191 CHECK_STATUS(status, NT_STATUS_OK);
192 cli->session->pid++;
193 status = smb_raw_lock(cli->tree, &io);
194 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
195 cli->session->pid--;
196 io.lock.level = RAW_LOCK_UNLOCK;
197 status = smb_raw_lock(cli->tree, &io);
198 CHECK_STATUS(status, NT_STATUS_OK);
199 io.lock.level = RAW_LOCK_UNLOCK;
200 status = smb_raw_lock(cli->tree, &io);
201 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
202
203 torture_comment(tctx, "Trying wrong pid unlock\n");
204 io.lock.level = RAW_LOCK_LOCK;
205 io.lock.in.file.fnum = fnum;
206 io.lock.in.count = 4002;
207 io.lock.in.offset = 10001;
208 status = smb_raw_lock(cli->tree, &io);
209 CHECK_STATUS(status, NT_STATUS_OK);
210 cli->session->pid++;
211 io.lock.level = RAW_LOCK_UNLOCK;
212 status = smb_raw_lock(cli->tree, &io);
213 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
214 cli->session->pid--;
215 status = smb_raw_lock(cli->tree, &io);
216 CHECK_STATUS(status, NT_STATUS_OK);
217
218 done:
219 smbcli_close(cli->tree, fnum);
220 smb_raw_exit(cli->session);
221 smbcli_deltree(cli->tree, BASEDIR);
222 return ret;
223 }
224
225
226 /*
227 test locking&X ops
228 */
229 static bool test_lockx(struct torture_context *tctx, struct smbcli_state *cli)
230 {
231 union smb_lock io;
232 struct smb_lock_entry lock[1];
233 NTSTATUS status;
234 bool ret = true;
235 int fnum;
236 const char *fname = BASEDIR "\\test.txt";
237
238 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
239
240 torture_comment(tctx, "Testing RAW_LOCK_LOCKX\n");
241 io.generic.level = RAW_LOCK_LOCKX;
242
243 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
244 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
245 "Failed to create %s - %s\n",
246 fname, smbcli_errstr(cli->tree)));
247
248 io.lockx.level = RAW_LOCK_LOCKX;
249 io.lockx.in.file.fnum = fnum;
250 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
251 io.lockx.in.timeout = 0;
252 io.lockx.in.ulock_cnt = 0;
253 io.lockx.in.lock_cnt = 1;
254 lock[0].pid = cli->session->pid;
255 lock[0].offset = 10;
256 lock[0].count = 1;
257 io.lockx.in.locks = &lock[0];
258 status = smb_raw_lock(cli->tree, &io);
259 CHECK_STATUS(status, NT_STATUS_OK);
260
261
262 torture_comment(tctx, "Trying 0xEEFFFFFF lock\n");
263 io.lockx.in.ulock_cnt = 0;
264 io.lockx.in.lock_cnt = 1;
265 lock[0].count = 4000;
266 lock[0].offset = 0xEEFFFFFF;
267 status = smb_raw_lock(cli->tree, &io);
268 CHECK_STATUS(status, NT_STATUS_OK);
269 lock[0].pid++;
270 status = smb_raw_lock(cli->tree, &io);
271 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
272 lock[0].pid--;
273 io.lockx.in.ulock_cnt = 1;
274 io.lockx.in.lock_cnt = 0;
275 status = smb_raw_lock(cli->tree, &io);
276 CHECK_STATUS(status, NT_STATUS_OK);
277 status = smb_raw_lock(cli->tree, &io);
278 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
279
280 torture_comment(tctx, "Trying 0xEF000000 lock\n");
281 io.lockx.in.ulock_cnt = 0;
282 io.lockx.in.lock_cnt = 1;
283 lock[0].count = 4000;
284 lock[0].offset = 0xEF000000;
285 status = smb_raw_lock(cli->tree, &io);
286 CHECK_STATUS(status, NT_STATUS_OK);
287 lock[0].pid++;
288 status = smb_raw_lock(cli->tree, &io);
289 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
290 lock[0].pid--;
291 io.lockx.in.ulock_cnt = 1;
292 io.lockx.in.lock_cnt = 0;
293 status = smb_raw_lock(cli->tree, &io);
294 CHECK_STATUS(status, NT_STATUS_OK);
295 status = smb_raw_lock(cli->tree, &io);
296 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
297
298 torture_comment(tctx, "Trying zero lock\n");
299 io.lockx.in.ulock_cnt = 0;
300 io.lockx.in.lock_cnt = 1;
301 lock[0].count = 0;
302 lock[0].offset = ~0;
303 status = smb_raw_lock(cli->tree, &io);
304 CHECK_STATUS(status, NT_STATUS_OK);
305 lock[0].pid++;
306 status = smb_raw_lock(cli->tree, &io);
307 CHECK_STATUS(status, NT_STATUS_OK);
308 lock[0].pid--;
309 io.lockx.in.ulock_cnt = 1;
310 io.lockx.in.lock_cnt = 0;
311 status = smb_raw_lock(cli->tree, &io);
312 CHECK_STATUS(status, NT_STATUS_OK);
313 status = smb_raw_lock(cli->tree, &io);
314 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
315
316 torture_comment(tctx, "Trying max lock\n");
317 io.lockx.in.ulock_cnt = 0;
318 io.lockx.in.lock_cnt = 1;
319 lock[0].count = 0;
320 lock[0].offset = ~0;
321 status = smb_raw_lock(cli->tree, &io);
322 CHECK_STATUS(status, NT_STATUS_OK);
323 lock[0].pid++;
324 status = smb_raw_lock(cli->tree, &io);
325 CHECK_STATUS(status, NT_STATUS_OK);
326 lock[0].pid--;
327 io.lockx.in.ulock_cnt = 1;
328 io.lockx.in.lock_cnt = 0;
329 status = smb_raw_lock(cli->tree, &io);
330 CHECK_STATUS(status, NT_STATUS_OK);
331 status = smb_raw_lock(cli->tree, &io);
332 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
333
334 torture_comment(tctx, "Trying 2^63\n");
335 io.lockx.in.ulock_cnt = 0;
336 io.lockx.in.lock_cnt = 1;
337 lock[0].count = 1;
338 lock[0].offset = 1;
339 lock[0].offset <<= 63;
340 status = smb_raw_lock(cli->tree, &io);
341 CHECK_STATUS(status, NT_STATUS_OK);
342 lock[0].pid++;
343 status = smb_raw_lock(cli->tree, &io);
344 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
345 lock[0].pid--;
346 io.lockx.in.ulock_cnt = 1;
347 io.lockx.in.lock_cnt = 0;
348 status = smb_raw_lock(cli->tree, &io);
349 CHECK_STATUS(status, NT_STATUS_OK);
350 status = smb_raw_lock(cli->tree, &io);
351 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
352
353 torture_comment(tctx, "Trying 2^63 - 1\n");
354 io.lockx.in.ulock_cnt = 0;
355 io.lockx.in.lock_cnt = 1;
356 lock[0].count = 1;
357 lock[0].offset = 1;
358 lock[0].offset <<= 63;
359 lock[0].offset--;
360 status = smb_raw_lock(cli->tree, &io);
361 CHECK_STATUS(status, NT_STATUS_OK);
362 lock[0].pid++;
363 status = smb_raw_lock(cli->tree, &io);
364 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
365 lock[0].pid--;
366 io.lockx.in.ulock_cnt = 1;
367 io.lockx.in.lock_cnt = 0;
368 status = smb_raw_lock(cli->tree, &io);
369 CHECK_STATUS(status, NT_STATUS_OK);
370 status = smb_raw_lock(cli->tree, &io);
371 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
372
373 torture_comment(tctx, "Trying max lock 2\n");
374 io.lockx.in.ulock_cnt = 0;
375 io.lockx.in.lock_cnt = 1;
376 lock[0].count = 1;
377 lock[0].offset = ~0;
378 status = smb_raw_lock(cli->tree, &io);
379 CHECK_STATUS(status, NT_STATUS_OK);
380 lock[0].pid++;
381 lock[0].count = 2;
382 status = smb_raw_lock(cli->tree, &io);
383 if (TARGET_SUPPORTS_INVALID_LOCK_RANGE(tctx))
384 CHECK_STATUS(status, NT_STATUS_INVALID_LOCK_RANGE);
385 else
386 CHECK_STATUS(status, NT_STATUS_OK);
387 lock[0].pid--;
388 io.lockx.in.ulock_cnt = 1;
389 io.lockx.in.lock_cnt = 0;
390 lock[0].count = 1;
391 status = smb_raw_lock(cli->tree, &io);
392
393 CHECK_STATUS(status, NT_STATUS_OK);
394 status = smb_raw_lock(cli->tree, &io);
395 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
396
397 done:
398 smbcli_close(cli->tree, fnum);
399 smb_raw_exit(cli->session);
400 smbcli_deltree(cli->tree, BASEDIR);
401 return ret;
402 }
403
404 /*
405 test high pid
406 */
407 static bool test_pidhigh(struct torture_context *tctx,
408 struct smbcli_state *cli)
409 {
410 union smb_lock io;
411 struct smb_lock_entry lock[1];
412 NTSTATUS status;
413 bool ret = true;
414 int fnum;
415 const char *fname = BASEDIR "\\test.txt";
416 uint8_t c = 1;
417
418 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
419
420 torture_comment(tctx, "Testing high pid\n");
421 io.generic.level = RAW_LOCK_LOCKX;
422
423 cli->session->pid = 1;
424
425 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
426 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
427 "Failed to create %s - %s\n",
428 fname, smbcli_errstr(cli->tree)));
429
430 if (smbcli_write(cli->tree, fnum, 0, &c, 0, 1) != 1) {
431 torture_result(tctx, TORTURE_FAIL,
432 "Failed to write 1 byte - %s\n",
433 smbcli_errstr(cli->tree));
434 ret = false;
435 goto done;
436 }
437
438 io.lockx.level = RAW_LOCK_LOCKX;
439 io.lockx.in.file.fnum = fnum;
440 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
441 io.lockx.in.timeout = 0;
442 io.lockx.in.ulock_cnt = 0;
443 io.lockx.in.lock_cnt = 1;
444 lock[0].pid = cli->session->pid;
445 lock[0].offset = 0;
446 lock[0].count = 0xFFFFFFFF;
447 io.lockx.in.locks = &lock[0];
448 status = smb_raw_lock(cli->tree, &io);
449 CHECK_STATUS(status, NT_STATUS_OK);
450
451 if (smbcli_read(cli->tree, fnum, &c, 0, 1) != 1) {
452 torture_result(tctx, TORTURE_FAIL,
453 "Failed to read 1 byte - %s\n",
454 smbcli_errstr(cli->tree));
455 ret = false;
456 goto done;
457 }
458
459 cli->session->pid = 2;
460
461 if (smbcli_read(cli->tree, fnum, &c, 0, 1) == 1) {
462 torture_result(tctx, TORTURE_FAIL,
463 "pid is incorrect handled for read with lock!\n");
464 ret = false;
465 goto done;
466 }
467
468 cli->session->pid = 0x10001;
469
470 if (smbcli_read(cli->tree, fnum, &c, 0, 1) != 1) {
471 torture_result(tctx, TORTURE_FAIL,
472 "High pid is used on this server!\n");
473 ret = false;
474 } else {
475 torture_warning(tctx, "High pid is not used on this server (correct)\n");
476 }
477
478 done:
479 smbcli_close(cli->tree, fnum);
480 smb_raw_exit(cli->session);
481 smbcli_deltree(cli->tree, BASEDIR);
482 return ret;
483 }
484
485
486 /*
487 test locking&X async operation
488 */
489 static bool test_async(struct torture_context *tctx,
490 struct smbcli_state *cli)
491 {
492 struct smbcli_session *session;
493 struct smb_composite_sesssetup setup;
494 struct smbcli_tree *tree;
495 union smb_tcon tcon;
496 const char *host, *share;
497 union smb_lock io;
498 struct smb_lock_entry lock[2];
499 NTSTATUS status;
500 bool ret = true;
501 int fnum;
502 const char *fname = BASEDIR "\\test.txt";
503 time_t t;
504 struct smbcli_request *req, *req2;
505 struct smbcli_session_options options;
506
507 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
508
509 lpcfg_smbcli_session_options(tctx->lp_ctx, &options);
510
511 torture_comment(tctx, "Testing LOCKING_ANDX_CANCEL_LOCK\n");
512 io.generic.level = RAW_LOCK_LOCKX;
513
514 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
515 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
516 "Failed to create %s - %s\n",
517 fname, smbcli_errstr(cli->tree)));
518
519 io.lockx.level = RAW_LOCK_LOCKX;
520 io.lockx.in.file.fnum = fnum;
521 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
522 io.lockx.in.timeout = 0;
523 io.lockx.in.ulock_cnt = 0;
524 io.lockx.in.lock_cnt = 1;
525 lock[0].pid = cli->session->pid;
526 lock[0].offset = 100;
527 lock[0].count = 10;
528 lock[1].pid = cli->session->pid;
529 lock[1].offset = 110;
530 lock[1].count = 10;
531 io.lockx.in.locks = &lock[0];
532 status = smb_raw_lock(cli->tree, &io);
533 CHECK_STATUS(status, NT_STATUS_OK);
534
535 t = time_mono(NULL);
536
537 torture_comment(tctx, "Testing cancel by CANCEL_LOCK\n");
538
539 /* setup a timed lock */
540 io.lockx.in.timeout = 10000;
541 req = smb_raw_lock_send(cli->tree, &io);
542 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
543 "Failed to setup timed lock (%s)\n", __location__));
544
545 /* cancel the wrong range */
546 lock[0].offset = 0;
547 io.lockx.in.timeout = 0;
548 io.lockx.in.mode = LOCKING_ANDX_CANCEL_LOCK;
549 status = smb_raw_lock(cli->tree, &io);
550 CHECK_STATUS(status, NT_STATUS_DOS(ERRDOS, ERRcancelviolation));
551
552 /* cancel with the wrong bits set */
553 lock[0].offset = 100;
554 io.lockx.in.timeout = 0;
555 io.lockx.in.mode = LOCKING_ANDX_CANCEL_LOCK;
556 status = smb_raw_lock(cli->tree, &io);
557 CHECK_STATUS(status, NT_STATUS_DOS(ERRDOS, ERRcancelviolation));
558
559 /* cancel the right range */
560 lock[0].offset = 100;
561 io.lockx.in.timeout = 0;
562 io.lockx.in.mode = LOCKING_ANDX_CANCEL_LOCK | LOCKING_ANDX_LARGE_FILES;
563 status = smb_raw_lock(cli->tree, &io);
564 CHECK_STATUS(status, NT_STATUS_OK);
565
566 /* receive the failed lock request */
567 status = smbcli_request_simple_recv(req);
568 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
569
570 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
571 "lock cancel was not immediate (%s)\n", __location__));
572
573 /* MS-CIFS (2.2.4.32.1) states that a cancel is honored if and only
574 * if the lock vector contains one entry. When given mutliple cancel
575 * requests in a single PDU we expect the server to return an
576 * error. Samba4 handles this correctly. Windows servers seem to
577 * accept the request but only cancel the first lock. Samba3
578 * now does what Windows does (JRA).
579 */
580 torture_comment(tctx, "Testing multiple cancel\n");
581
582 /* acquire second lock */
583 io.lockx.in.timeout = 0;
584 io.lockx.in.ulock_cnt = 0;
585 io.lockx.in.lock_cnt = 1;
586 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
587 io.lockx.in.locks = &lock[1];
588 status = smb_raw_lock(cli->tree, &io);
589 CHECK_STATUS(status, NT_STATUS_OK);
590
591 /* setup 2 timed locks */
592 t = time_mono(NULL);
593 io.lockx.in.timeout = 10000;
594 io.lockx.in.lock_cnt = 1;
595 io.lockx.in.locks = &lock[0];
596 req = smb_raw_lock_send(cli->tree, &io);
597 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
598 "Failed to setup timed lock (%s)\n", __location__));
599 io.lockx.in.locks = &lock[1];
600 req2 = smb_raw_lock_send(cli->tree, &io);
601 torture_assert(tctx,(req2 != NULL), talloc_asprintf(tctx,
602 "Failed to setup timed lock (%s)\n", __location__));
603
604 /* try to cancel both locks in the same packet */
605 io.lockx.in.timeout = 0;
606 io.lockx.in.lock_cnt = 2;
607 io.lockx.in.mode = LOCKING_ANDX_CANCEL_LOCK | LOCKING_ANDX_LARGE_FILES;
608 io.lockx.in.locks = lock;
609 status = smb_raw_lock(cli->tree, &io);
610 CHECK_STATUS(status, NT_STATUS_OK);
611
612 torture_warning(tctx, "Target server accepted a lock cancel "
613 "request with multiple locks. This violates "
614 "MS-CIFS 2.2.4.32.1.\n");
615
616 /* receive the failed lock requests */
617 status = smbcli_request_simple_recv(req);
618 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
619
620 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
621 "first lock was not cancelled immediately (%s)\n",
622 __location__));
623
624 /* send cancel to second lock */
625 io.lockx.in.timeout = 0;
626 io.lockx.in.lock_cnt = 1;
627 io.lockx.in.mode = LOCKING_ANDX_CANCEL_LOCK |
628 LOCKING_ANDX_LARGE_FILES;
629 io.lockx.in.locks = &lock[1];
630 status = smb_raw_lock(cli->tree, &io);
631 CHECK_STATUS(status, NT_STATUS_OK);
632
633 status = smbcli_request_simple_recv(req2);
634 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
635
636 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
637 "second lock was not cancelled immediately (%s)\n",
638 __location__));
639
640 /* cleanup the second lock */
641 io.lockx.in.ulock_cnt = 1;
642 io.lockx.in.lock_cnt = 0;
643 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
644 io.lockx.in.locks = &lock[1];
645 status = smb_raw_lock(cli->tree, &io);
646 CHECK_STATUS(status, NT_STATUS_OK);
647
648 /* If a lock request contained multiple ranges and we are cancelling
649 * one while it's still pending, what happens? */
650 torture_comment(tctx, "Testing cancel 1/2 lock request\n");
651
652 /* Send request with two ranges */
653 io.lockx.in.timeout = -1;
654 io.lockx.in.ulock_cnt = 0;
655 io.lockx.in.lock_cnt = 2;
656 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
657 io.lockx.in.locks = lock;
658 req = smb_raw_lock_send(cli->tree, &io);
659 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
660 "Failed to setup pending lock (%s)\n", __location__));
661
662 /* Try to cancel the first lock range */
663 io.lockx.in.timeout = 0;
664 io.lockx.in.lock_cnt = 1;
665 io.lockx.in.mode = LOCKING_ANDX_CANCEL_LOCK | LOCKING_ANDX_LARGE_FILES;
666 io.lockx.in.locks = &lock[0];
667 status = smb_raw_lock(cli->tree, &io);
668 CHECK_STATUS(status, NT_STATUS_OK);
669
670 /* Locking request should've failed and second range should be
671 * unlocked */
672 status = smbcli_request_simple_recv(req);
673 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
674
675 io.lockx.in.timeout = 0;
676 io.lockx.in.ulock_cnt = 0;
677 io.lockx.in.lock_cnt = 1;
678 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
679 io.lockx.in.locks = &lock[1];
680 status = smb_raw_lock(cli->tree, &io);
681 CHECK_STATUS(status, NT_STATUS_OK);
682
683 /* Cleanup both locks */
684 io.lockx.in.ulock_cnt = 2;
685 io.lockx.in.lock_cnt = 0;
686 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
687 io.lockx.in.locks = lock;
688 status = smb_raw_lock(cli->tree, &io);
689 CHECK_STATUS(status, NT_STATUS_OK);
690
691 torture_comment(tctx, "Testing cancel 2/2 lock request\n");
692
693 /* Lock second range so it contends */
694 io.lockx.in.timeout = 0;
695 io.lockx.in.ulock_cnt = 0;
696 io.lockx.in.lock_cnt = 1;
697 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
698 io.lockx.in.locks = &lock[1];
699 status = smb_raw_lock(cli->tree, &io);
700 CHECK_STATUS(status, NT_STATUS_OK);
701
702 /* Send request with two ranges */
703 io.lockx.in.timeout = -1;
704 io.lockx.in.ulock_cnt = 0;
705 io.lockx.in.lock_cnt = 2;
706 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
707 io.lockx.in.locks = lock;
708 req = smb_raw_lock_send(cli->tree, &io);
709 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
710 "Failed to setup pending lock (%s)\n", __location__));
711
712 /* Try to cancel the second lock range */
713 io.lockx.in.timeout = 0;
714 io.lockx.in.lock_cnt = 1;
715 io.lockx.in.mode = LOCKING_ANDX_CANCEL_LOCK | LOCKING_ANDX_LARGE_FILES;
716 io.lockx.in.locks = &lock[1];
717 status = smb_raw_lock(cli->tree, &io);
718 CHECK_STATUS(status, NT_STATUS_OK);
719
720 /* Locking request should've failed and first range should be
721 * unlocked */
722 status = smbcli_request_simple_recv(req);
723 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
724
725 io.lockx.in.timeout = 0;
726 io.lockx.in.ulock_cnt = 0;
727 io.lockx.in.lock_cnt = 1;
728 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
729 io.lockx.in.locks = &lock[0];
730 status = smb_raw_lock(cli->tree, &io);
731 CHECK_STATUS(status, NT_STATUS_OK);
732
733 /* Cleanup both locks */
734 io.lockx.in.ulock_cnt = 2;
735 io.lockx.in.lock_cnt = 0;
736 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
737 io.lockx.in.locks = lock;
738 status = smb_raw_lock(cli->tree, &io);
739 CHECK_STATUS(status, NT_STATUS_OK);
740
741 torture_comment(tctx, "Testing cancel by unlock\n");
742 io.lockx.in.ulock_cnt = 0;
743 io.lockx.in.lock_cnt = 1;
744 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
745 io.lockx.in.timeout = 0;
746 io.lockx.in.locks = &lock[0];
747 status = smb_raw_lock(cli->tree, &io);
748 CHECK_STATUS(status, NT_STATUS_OK);
749
750 io.lockx.in.timeout = 5000;
751 req = smb_raw_lock_send(cli->tree, &io);
752 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
753 "Failed to setup timed lock (%s)\n", __location__));
754
755 io.lockx.in.ulock_cnt = 1;
756 io.lockx.in.lock_cnt = 0;
757 status = smb_raw_lock(cli->tree, &io);
758 CHECK_STATUS(status, NT_STATUS_OK);
759
760 t = time_mono(NULL);
761 status = smbcli_request_simple_recv(req);
762 CHECK_STATUS(status, NT_STATUS_OK);
763
764 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
765 "lock cancel by unlock was not immediate (%s) - took %d secs\n",
766 __location__, (int)(time_mono(NULL)-t)));
767
768 torture_comment(tctx, "Testing cancel by close\n");
769 io.lockx.in.ulock_cnt = 0;
770 io.lockx.in.lock_cnt = 1;
771 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
772 io.lockx.in.timeout = 0;
773 status = smb_raw_lock(cli->tree, &io);
774 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
775
776 {
777 /*
778 * Make the test block on the second lock
779 * request. This is to regression-test 64c0367.
780 */
781 uint64_t tmp = lock[1].offset;
782 lock[1].offset = lock[0].offset;
783 lock[0].offset = tmp;
784 }
785
786 t = time_mono(NULL);
787 io.lockx.in.timeout = 10000;
788 io.lockx.in.lock_cnt = 2;
789 req = smb_raw_lock_send(cli->tree, &io);
790 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
791 "Failed to setup timed lock (%s)\n", __location__));
792
793 status = smbcli_close(cli->tree, fnum);
794 CHECK_STATUS(status, NT_STATUS_OK);
795
796 status = smbcli_request_simple_recv(req);
797 if (TARGET_RETURNS_RANGE_NOT_LOCKED(tctx))
798 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
799 else
800 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
801
802 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
803 "lock cancel by close was not immediate (%s)\n", __location__));
804
805 {
806 /*
807 * Undo the change for 64c0367
808 */
809 uint64_t tmp = lock[1].offset;
810 lock[1].offset = lock[0].offset;
811 lock[0].offset = tmp;
812 }
813
814 torture_comment(tctx, "create a new sessions\n");
815 session = smbcli_session_init(cli->transport, tctx, false, options);
816 setup.in.sesskey = cli->transport->negotiate.sesskey;
817 setup.in.capabilities = cli->transport->negotiate.capabilities;
818 setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
819 setup.in.credentials = cmdline_credentials;
820 setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
821 status = smb_composite_sesssetup(session, &setup);
822 CHECK_STATUS(status, NT_STATUS_OK);
823 session->vuid = setup.out.vuid;
824
825 torture_comment(tctx, "create new tree context\n");
826 share = torture_setting_string(tctx, "share", NULL);
827 host = torture_setting_string(tctx, "host", NULL);
828 tree = smbcli_tree_init(session, tctx, false);
829 tcon.generic.level = RAW_TCON_TCONX;
830 tcon.tconx.in.flags = TCONX_FLAG_EXTENDED_RESPONSE;
831 tcon.tconx.in.password = data_blob(NULL, 0);
832 tcon.tconx.in.path = talloc_asprintf(tctx, "\\\\%s\\%s", host, share);
833 tcon.tconx.in.device = "A:";
834 status = smb_raw_tcon(tree, tctx, &tcon);
835 CHECK_STATUS(status, NT_STATUS_OK);
836 tree->tid = tcon.tconx.out.tid;
837
838 torture_comment(tctx, "Testing cancel by exit\n");
839 if (TARGET_SUPPORTS_SMBEXIT(tctx)) {
840 fname = BASEDIR "\\test_exit.txt";
841 fnum = smbcli_open(tree, fname, O_RDWR|O_CREAT, DENY_NONE);
842 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
843 "Failed to reopen %s - %s\n",
844 fname, smbcli_errstr(tree)));
845
846 io.lockx.level = RAW_LOCK_LOCKX;
847 io.lockx.in.file.fnum = fnum;
848 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
849 io.lockx.in.timeout = 0;
850 io.lockx.in.ulock_cnt = 0;
851 io.lockx.in.lock_cnt = 1;
852 lock[0].pid = session->pid;
853 lock[0].offset = 100;
854 lock[0].count = 10;
855 io.lockx.in.locks = &lock[0];
856 status = smb_raw_lock(tree, &io);
857 CHECK_STATUS(status, NT_STATUS_OK);
858
859 io.lockx.in.ulock_cnt = 0;
860 io.lockx.in.lock_cnt = 1;
861 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
862 io.lockx.in.timeout = 0;
863 status = smb_raw_lock(tree, &io);
864 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
865
866 io.lockx.in.timeout = 10000;
867 t = time_mono(NULL);
868 req = smb_raw_lock_send(tree, &io);
869 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
870 "Failed to setup timed lock (%s)\n",
871 __location__));
872
873 status = smb_raw_exit(session);
874 CHECK_STATUS(status, NT_STATUS_OK);
875
876 status = smbcli_request_simple_recv(req);
877 if (TARGET_RETURNS_RANGE_NOT_LOCKED(tctx))
878 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
879 else
880 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
881
882 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
883 "lock cancel by exit was not immediate (%s)\n",
884 __location__));
885 }
886 else {
887 torture_comment(tctx,
888 " skipping test, SMBExit not supported\n");
889 }
890
891 torture_comment(tctx, "Testing cancel by ulogoff\n");
892 fname = BASEDIR "\\test_ulogoff.txt";
893 fnum = smbcli_open(tree, fname, O_RDWR|O_CREAT, DENY_NONE);
894 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
895 "Failed to reopen %s - %s\n",
896 fname, smbcli_errstr(tree)));
897
898 io.lockx.level = RAW_LOCK_LOCKX;
899 io.lockx.in.file.fnum = fnum;
900 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
901 io.lockx.in.timeout = 0;
902 io.lockx.in.ulock_cnt = 0;
903 io.lockx.in.lock_cnt = 1;
904 lock[0].pid = session->pid;
905 lock[0].offset = 100;
906 lock[0].count = 10;
907 io.lockx.in.locks = &lock[0];
908 status = smb_raw_lock(tree, &io);
909 CHECK_STATUS(status, NT_STATUS_OK);
910
911 io.lockx.in.ulock_cnt = 0;
912 io.lockx.in.lock_cnt = 1;
913 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
914 io.lockx.in.timeout = 0;
915 status = smb_raw_lock(tree, &io);
916 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
917
918 io.lockx.in.timeout = 10000;
919 t = time_mono(NULL);
920 req = smb_raw_lock_send(tree, &io);
921 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
922 "Failed to setup timed lock (%s)\n", __location__));
923
924 status = smb_raw_ulogoff(session);
925 CHECK_STATUS(status, NT_STATUS_OK);
926
927 status = smbcli_request_simple_recv(req);
928 if (TARGET_RETURNS_RANGE_NOT_LOCKED(tctx)) {
929 if (NT_STATUS_EQUAL(NT_STATUS_FILE_LOCK_CONFLICT, status)) {
930 torture_result(tctx, TORTURE_FAIL,
931 "lock not canceled by ulogoff - %s "
932 "(ignored because of vfs_vifs fails it)\n",
933 nt_errstr(status));
934 smb_tree_disconnect(tree);
935 smb_raw_exit(session);
936 goto done;
937 }
938 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
939 } else {
940 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
941 }
942
943 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
944 "lock cancel by ulogoff was not immediate (%s)\n", __location__));
945
946 torture_comment(tctx, "Testing cancel by tdis\n");
947 tree->session = cli->session;
948
949 fname = BASEDIR "\\test_tdis.txt";
950 fnum = smbcli_open(tree, fname, O_RDWR|O_CREAT, DENY_NONE);
951 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
952 "Failed to reopen %s - %s\n",
953 fname, smbcli_errstr(tree)));
954
955 io.lockx.level = RAW_LOCK_LOCKX;
956 io.lockx.in.file.fnum = fnum;
957 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
958 io.lockx.in.timeout = 0;
959 io.lockx.in.ulock_cnt = 0;
960 io.lockx.in.lock_cnt = 1;
961 lock[0].pid = cli->session->pid;
962 lock[0].offset = 100;
963 lock[0].count = 10;
964 io.lockx.in.locks = &lock[0];
965 status = smb_raw_lock(tree, &io);
966 CHECK_STATUS(status, NT_STATUS_OK);
967
968 status = smb_raw_lock(tree, &io);
969 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
970
971 io.lockx.in.timeout = 10000;
972 t = time_mono(NULL);
973 req = smb_raw_lock_send(tree, &io);
974 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
975 "Failed to setup timed lock (%s)\n", __location__));
976
977 status = smb_tree_disconnect(tree);
978 CHECK_STATUS(status, NT_STATUS_OK);
979
980 status = smbcli_request_simple_recv(req);
981 if (TARGET_RETURNS_RANGE_NOT_LOCKED(tctx))
982 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
983 else
984 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
985
986 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
987 "lock cancel by tdis was not immediate (%s)\n", __location__));
988
989 done:
990 smb_raw_exit(cli->session);
991 smbcli_deltree(cli->tree, BASEDIR);
992 return ret;
993 }
994
995 /*
996 test NT_STATUS_LOCK_NOT_GRANTED vs. NT_STATUS_FILE_LOCK_CONFLICT
997 */
998 static bool test_errorcode(struct torture_context *tctx,
999 struct smbcli_state *cli)
1000 {
1001 union smb_lock io;
1002 union smb_open op;
1003 struct smb_lock_entry lock[2];
1004 NTSTATUS status;
1005 bool ret = true;
1006 int fnum, fnum2;
1007 const char *fname;
1008 struct smbcli_request *req;
1009 time_t start;
1010 int t;
1011 int delay;
1012 uint16_t deny_mode = 0;
1013
1014 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1015
1016 torture_comment(tctx, "Testing LOCK_NOT_GRANTED vs. FILE_LOCK_CONFLICT\n");
1017
1018 torture_comment(tctx, "Testing with timeout = 0\n");
1019 fname = BASEDIR "\\test0.txt";
1020 t = 0;
1021
1022 /*
1023 * the first run is with t = 0,
1024 * the second with t > 0 (=1)
1025 */
1026 next_run:
1027 /*
1028 * use the DENY_DOS mode, that creates two fnum's of one low-level
1029 * file handle, this demonstrates that the cache is per fnum, not
1030 * per file handle
1031 */
1032 if (TARGET_SUPPORTS_OPENX_DENY_DOS(tctx))
1033 deny_mode = OPENX_MODE_DENY_DOS;
1034 else
1035 deny_mode = OPENX_MODE_DENY_NONE;
1036
1037 op.openx.level = RAW_OPEN_OPENX;
1038 op.openx.in.fname = fname;
1039 op.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
1040 op.openx.in.open_mode = OPENX_MODE_ACCESS_RDWR | deny_mode;
1041 op.openx.in.open_func = OPENX_OPEN_FUNC_OPEN | OPENX_OPEN_FUNC_CREATE;
1042 op.openx.in.search_attrs = 0;
1043 op.openx.in.file_attrs = 0;
1044 op.openx.in.write_time = 0;
1045 op.openx.in.size = 0;
1046 op.openx.in.timeout = 0;
1047
1048 status = smb_raw_open(cli->tree, tctx, &op);
1049 CHECK_STATUS(status, NT_STATUS_OK);
1050 fnum = op.openx.out.file.fnum;
1051
1052 status = smb_raw_open(cli->tree, tctx, &op);
1053 CHECK_STATUS(status, NT_STATUS_OK);
1054 fnum2 = op.openx.out.file.fnum;
1055
1056 io.lockx.level = RAW_LOCK_LOCKX;
1057 io.lockx.in.file.fnum = fnum;
1058 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
1059 io.lockx.in.timeout = t;
1060 io.lockx.in.ulock_cnt = 0;
1061 io.lockx.in.lock_cnt = 1;
1062 lock[0].pid = cli->session->pid;
1063 lock[0].offset = 100;
1064 lock[0].count = 10;
1065 io.lockx.in.locks = &lock[0];
1066 status = smb_raw_lock(cli->tree, &io);
1067 CHECK_STATUS(status, NT_STATUS_OK);
1068
1069 /*
1070 * demonstrate that the first conflicting lock on each handle give LOCK_NOT_GRANTED
1071 * this also demonstrates that the error code cache is per file handle
1072 * (LOCK_NOT_GRANTED is only be used when timeout is 0!)
1073 */
1074 io.lockx.in.file.fnum = fnum2;
1075 status = smb_raw_lock(cli->tree, &io);
1076 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1077
1078 io.lockx.in.file.fnum = fnum;
1079 status = smb_raw_lock(cli->tree, &io);
1080 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1081
1082 /* demonstrate that each following conflict gives FILE_LOCK_CONFLICT */
1083 io.lockx.in.file.fnum = fnum;
1084 status = smb_raw_lock(cli->tree, &io);
1085 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1086
1087 io.lockx.in.file.fnum = fnum2;
1088 status = smb_raw_lock(cli->tree, &io);
1089 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1090
1091 io.lockx.in.file.fnum = fnum;
1092 status = smb_raw_lock(cli->tree, &io);
1093 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1094
1095 io.lockx.in.file.fnum = fnum2;
1096 status = smb_raw_lock(cli->tree, &io);
1097 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1098
1099 /* demonstrate that the smbpid doesn't matter */
1100 lock[0].pid++;
1101 io.lockx.in.file.fnum = fnum;
1102 status = smb_raw_lock(cli->tree, &io);
1103 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1104
1105 io.lockx.in.file.fnum = fnum2;
1106 status = smb_raw_lock(cli->tree, &io);
1107 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1108 lock[0].pid--;
1109
1110 /*
1111 * demonstrate the a successful lock with count = 0 and the same offset,
1112 * doesn't reset the error cache
1113 */
1114 lock[0].offset = 100;
1115 lock[0].count = 0;
1116 io.lockx.in.file.fnum = fnum;
1117 status = smb_raw_lock(cli->tree, &io);
1118 CHECK_STATUS(status, NT_STATUS_OK);
1119
1120 io.lockx.in.file.fnum = fnum2;
1121 status = smb_raw_lock(cli->tree, &io);
1122 CHECK_STATUS(status, NT_STATUS_OK);
1123
1124 lock[0].offset = 100;
1125 lock[0].count = 10;
1126 io.lockx.in.file.fnum = fnum;
1127 status = smb_raw_lock(cli->tree, &io);
1128 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1129
1130 io.lockx.in.file.fnum = fnum2;
1131 status = smb_raw_lock(cli->tree, &io);
1132 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1133
1134 /*
1135 * demonstrate the a successful lock with count = 0 and outside the locked range,
1136 * doesn't reset the error cache
1137 */
1138 lock[0].offset = 110;
1139 lock[0].count = 0;
1140 io.lockx.in.file.fnum = fnum;
1141 status = smb_raw_lock(cli->tree, &io);
1142 CHECK_STATUS(status, NT_STATUS_OK);
1143
1144 io.lockx.in.file.fnum = fnum2;
1145 status = smb_raw_lock(cli->tree, &io);
1146 CHECK_STATUS(status, NT_STATUS_OK);
1147
1148 lock[0].offset = 100;
1149 lock[0].count = 10;
1150 io.lockx.in.file.fnum = fnum;
1151 status = smb_raw_lock(cli->tree, &io);
1152 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1153
1154 io.lockx.in.file.fnum = fnum2;
1155 status = smb_raw_lock(cli->tree, &io);
1156 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1157
1158 lock[0].offset = 99;
1159 lock[0].count = 0;
1160 io.lockx.in.file.fnum = fnum;
1161 status = smb_raw_lock(cli->tree, &io);
1162 CHECK_STATUS(status, NT_STATUS_OK);
1163
1164 io.lockx.in.file.fnum = fnum2;
1165 status = smb_raw_lock(cli->tree, &io);
1166 CHECK_STATUS(status, NT_STATUS_OK);
1167
1168 lock[0].offset = 100;
1169 lock[0].count = 10;
1170 io.lockx.in.file.fnum = fnum;
1171 status = smb_raw_lock(cli->tree, &io);
1172 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1173
1174 io.lockx.in.file.fnum = fnum2;
1175 status = smb_raw_lock(cli->tree, &io);
1176 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1177
1178 /* demonstrate that a changing count doesn't reset the error cache */
1179 lock[0].offset = 100;
1180 lock[0].count = 5;
1181 io.lockx.in.file.fnum = fnum;
1182 status = smb_raw_lock(cli->tree, &io);
1183 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1184
1185 io.lockx.in.file.fnum = fnum2;
1186 status = smb_raw_lock(cli->tree, &io);
1187 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1188
1189 lock[0].offset = 100;
1190 lock[0].count = 15;
1191 io.lockx.in.file.fnum = fnum;
1192 status = smb_raw_lock(cli->tree, &io);
1193 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1194
1195 io.lockx.in.file.fnum = fnum2;
1196 status = smb_raw_lock(cli->tree, &io);
1197 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1198
1199 /*
1200 * demonstrate the a lock with count = 0 and inside the locked range,
1201 * fails and resets the error cache
1202 */
1203 lock[0].offset = 101;
1204 lock[0].count = 0;
1205 io.lockx.in.file.fnum = fnum;
1206 status = smb_raw_lock(cli->tree, &io);
1207 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1208 status = smb_raw_lock(cli->tree, &io);
1209 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1210
1211 io.lockx.in.file.fnum = fnum2;
1212 status = smb_raw_lock(cli->tree, &io);
1213 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1214 status = smb_raw_lock(cli->tree, &io);
1215 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1216
1217 lock[0].offset = 100;
1218 lock[0].count = 10;
1219 io.lockx.in.file.fnum = fnum;
1220 status = smb_raw_lock(cli->tree, &io);
1221 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1222 status = smb_raw_lock(cli->tree, &io);
1223 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1224
1225 io.lockx.in.file.fnum = fnum2;
1226 status = smb_raw_lock(cli->tree, &io);
1227 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1228 status = smb_raw_lock(cli->tree, &io);
1229 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1230
1231 /* demonstrate the a changing offset, resets the error cache */
1232 lock[0].offset = 105;
1233 lock[0].count = 10;
1234 io.lockx.in.file.fnum = fnum;
1235 status = smb_raw_lock(cli->tree, &io);
1236 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1237 status = smb_raw_lock(cli->tree, &io);
1238 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1239
1240 io.lockx.in.file.fnum = fnum2;
1241 status = smb_raw_lock(cli->tree, &io);
1242 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1243 status = smb_raw_lock(cli->tree, &io);
1244 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1245
1246 lock[0].offset = 100;
1247 lock[0].count = 10;
1248 io.lockx.in.file.fnum = fnum;
1249 status = smb_raw_lock(cli->tree, &io);
1250 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1251 status = smb_raw_lock(cli->tree, &io);
1252 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1253
1254 io.lockx.in.file.fnum = fnum2;
1255 status = smb_raw_lock(cli->tree, &io);
1256 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1257 status = smb_raw_lock(cli->tree, &io);
1258 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1259
1260 lock[0].offset = 95;
1261 lock[0].count = 9;
1262 io.lockx.in.file.fnum = fnum;
1263 status = smb_raw_lock(cli->tree, &io);
1264 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1265 status = smb_raw_lock(cli->tree, &io);
1266 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1267
1268 io.lockx.in.file.fnum = fnum2;
1269 status = smb_raw_lock(cli->tree, &io);
1270 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1271 status = smb_raw_lock(cli->tree, &io);
1272 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1273
1274 lock[0].offset = 100;
1275 lock[0].count = 10;
1276 io.lockx.in.file.fnum = fnum;
1277 status = smb_raw_lock(cli->tree, &io);
1278 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1279 status = smb_raw_lock(cli->tree, &io);
1280 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1281
1282 io.lockx.in.file.fnum = fnum2;
1283 status = smb_raw_lock(cli->tree, &io);
1284 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1285 status = smb_raw_lock(cli->tree, &io);
1286 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1287
1288 /*
1289 * demonstrate the a successful lock in a different range,
1290 * doesn't reset the cache, the failing lock on the 2nd handle
1291 * resets the cache
1292 */
1293 lock[0].offset = 120;
1294 lock[0].count = 15;
1295 io.lockx.in.file.fnum = fnum;
1296 status = smb_raw_lock(cli->tree, &io);
1297 CHECK_STATUS(status, NT_STATUS_OK);
1298
1299 io.lockx.in.file.fnum = fnum2;
1300 status = smb_raw_lock(cli->tree, &io);
1301 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1302
1303 lock[0].offset = 100;
1304 lock[0].count = 10;
1305 io.lockx.in.file.fnum = fnum;
1306 status = smb_raw_lock(cli->tree, &io);
1307 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1308 status = smb_raw_lock(cli->tree, &io);
1309 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1310
1311 io.lockx.in.file.fnum = fnum2;
1312 status = smb_raw_lock(cli->tree, &io);
1313 CHECK_STATUS(status, (t?NT_STATUS_FILE_LOCK_CONFLICT:NT_STATUS_LOCK_NOT_GRANTED));
1314 status = smb_raw_lock(cli->tree, &io);
1315 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1316
1317 /* end of the loop */
1318 if (t == 0) {
1319 smb_raw_exit(cli->session);
1320 t = 1;
1321 torture_comment(tctx, "Testing with timeout > 0 (=%d)\n",
1322 t);
1323 fname = BASEDIR "\\test1.txt";
1324 goto next_run;
1325 }
1326
1327 t = 4000;
1328 torture_comment(tctx, "Testing special cases with timeout > 0 (=%d)\n",
1329 t);
1330
1331 /*
1332 * the following 3 test sections demonstrate that
1333 * the cache is only set when the error is reported
1334 * to the client (after the timeout went by)
1335 */
1336 smb_raw_exit(cli->session);
1337 torture_comment(tctx, "Testing a conflict while a lock is pending\n");
1338 fname = BASEDIR "\\test2.txt";
1339 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1340 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
1341 "Failed to reopen %s - %s\n",
1342 fname, smbcli_errstr(cli->tree)));
1343
1344 io.lockx.level = RAW_LOCK_LOCKX;
1345 io.lockx.in.file.fnum = fnum;
1346 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
1347 io.lockx.in.timeout = 0;
1348 io.lockx.in.ulock_cnt = 0;
1349 io.lockx.in.lock_cnt = 1;
1350 lock[0].pid = cli->session->pid;
1351 lock[0].offset = 100;
1352 lock[0].count = 10;
1353 io.lockx.in.locks = &lock[0];
1354 status = smb_raw_lock(cli->tree, &io);
1355 CHECK_STATUS(status, NT_STATUS_OK);
1356
1357 start = time_mono(NULL);
1358 io.lockx.in.timeout = t;
1359 req = smb_raw_lock_send(cli->tree, &io);
1360 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
1361 "Failed to setup timed lock (%s)\n", __location__));
1362
1363 io.lockx.in.timeout = 0;
1364 lock[0].offset = 105;
1365 lock[0].count = 10;
1366 status = smb_raw_lock(cli->tree, &io);
1367 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
1368
1369 status = smbcli_request_simple_recv(req);
1370 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1371
1372 delay = t / 1000;
1373 if (TARGET_IS_W2K8(tctx) || TARGET_IS_WIN7(tctx)) {
1374 delay /= 2;
1375 }
1376
1377 torture_assert(tctx,!(time_mono(NULL) < start+delay), talloc_asprintf(tctx,
1378 "lock comes back to early timeout[%d] delay[%d]"
1379 "(%s)\n", t, delay, __location__));
1380
1381 status = smb_raw_lock(cli->tree, &io);
1382 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
1383
1384 smbcli_close(cli->tree, fnum);
1385 fname = BASEDIR "\\test3.txt";
1386 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1387 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
1388 "Failed to reopen %s - %s\n",
1389 fname, smbcli_errstr(cli->tree)));
1390
1391 io.lockx.level = RAW_LOCK_LOCKX;
1392 io.lockx.in.file.fnum = fnum;
1393 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
1394 io.lockx.in.timeout = 0;
1395 io.lockx.in.ulock_cnt = 0;
1396 io.lockx.in.lock_cnt = 1;
1397 lock[0].pid = cli->session->pid;
1398 lock[0].offset = 100;
1399 lock[0].count = 10;
1400 io.lockx.in.locks = &lock[0];
1401 status = smb_raw_lock(cli->tree, &io);
1402 CHECK_STATUS(status, NT_STATUS_OK);
1403
1404 start = time_mono(NULL);
1405 io.lockx.in.timeout = t;
1406 req = smb_raw_lock_send(cli->tree, &io);
1407 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
1408 "Failed to setup timed lock (%s)\n", __location__));
1409
1410 io.lockx.in.timeout = 0;
1411 lock[0].offset = 105;
1412 lock[0].count = 10;
1413 status = smb_raw_lock(cli->tree, &io);
1414 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
1415
1416 status = smbcli_request_simple_recv(req);
1417 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1418
1419 delay = t / 1000;
1420 if (TARGET_IS_W2K8(tctx) || TARGET_IS_WIN7(tctx)) {
1421 delay /= 2;
1422 }
1423
1424 torture_assert(tctx,!(time_mono(NULL) < start+delay), talloc_asprintf(tctx,
1425 "lock comes back to early timeout[%d] delay[%d]"
1426 "(%s)\n", t, delay, __location__));
1427
1428 lock[0].offset = 100;
1429 lock[0].count = 10;
1430 status = smb_raw_lock(cli->tree, &io);
1431 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1432
1433 smbcli_close(cli->tree, fnum);
1434 fname = BASEDIR "\\test4.txt";
1435 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1436 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
1437 "Failed to reopen %s - %s\n",
1438 fname, smbcli_errstr(cli->tree)));
1439
1440 io.lockx.level = RAW_LOCK_LOCKX;
1441 io.lockx.in.file.fnum = fnum;
1442 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
1443 io.lockx.in.timeout = 0;
1444 io.lockx.in.ulock_cnt = 0;
1445 io.lockx.in.lock_cnt = 1;
1446 lock[0].pid = cli->session->pid;
1447 lock[0].offset = 100;
1448 lock[0].count = 10;
1449 io.lockx.in.locks = &lock[0];
1450 status = smb_raw_lock(cli->tree, &io);
1451 CHECK_STATUS(status, NT_STATUS_OK);
1452
1453 start = time_mono(NULL);
1454 io.lockx.in.timeout = t;
1455 req = smb_raw_lock_send(cli->tree, &io);
1456 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
1457 "Failed to setup timed lock (%s)\n", __location__));
1458
1459 io.lockx.in.timeout = 0;
1460 status = smb_raw_lock(cli->tree, &io);
1461 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
1462
1463 status = smbcli_request_simple_recv(req);
1464 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1465
1466 delay = t / 1000;
1467 if (TARGET_IS_W2K8(tctx) || TARGET_IS_WIN7(tctx)) {
1468 delay /= 2;
1469 }
1470
1471 torture_assert(tctx,!(time_mono(NULL) < start+delay), talloc_asprintf(tctx,
1472 "lock comes back to early timeout[%d] delay[%d]"
1473 "(%s)\n", t, delay, __location__));
1474
1475 status = smb_raw_lock(cli->tree, &io);
1476 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1477
1478 done:
1479 smb_raw_exit(cli->session);
1480 smbcli_deltree(cli->tree, BASEDIR);
1481 return ret;
1482 }
1483
1484
1485 /*
1486 test LOCKING_ANDX_CHANGE_LOCKTYPE
1487 */
1488 static bool test_changetype(struct torture_context *tctx,
1489 struct smbcli_state *cli)
1490 {
1491 union smb_lock io;
1492 struct smb_lock_entry lock[2];
1493 NTSTATUS status;
1494 bool ret = true;
1495 int fnum;
1496 uint8_t c = 0;
1497 const char *fname = BASEDIR "\\test.txt";
1498
1499 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1500
1501 torture_comment(tctx, "Testing LOCKING_ANDX_CHANGE_LOCKTYPE\n");
1502 io.generic.level = RAW_LOCK_LOCKX;
1503
1504 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1505 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
1506 "Failed to create %s - %s\n",
1507 fname, smbcli_errstr(cli->tree)));
1508
1509 io.lockx.level = RAW_LOCK_LOCKX;
1510 io.lockx.in.file.fnum = fnum;
1511 io.lockx.in.mode = LOCKING_ANDX_SHARED_LOCK;
1512 io.lockx.in.timeout = 0;
1513 io.lockx.in.ulock_cnt = 0;
1514 io.lockx.in.lock_cnt = 1;
1515 lock[0].pid = cli->session->pid;
1516 lock[0].offset = 100;
1517 lock[0].count = 10;
1518 io.lockx.in.locks = &lock[0];
1519 status = smb_raw_lock(cli->tree, &io);
1520 CHECK_STATUS(status, NT_STATUS_OK);
1521
1522 if (smbcli_write(cli->tree, fnum, 0, &c, 100, 1) == 1) {
1523 torture_result(tctx, TORTURE_FAIL,
1524 "allowed write on read locked region (%s)\n", __location__);
1525 ret = false;
1526 goto done;
1527 }
1528
1529 /* windows server don't seem to support this */
1530 io.lockx.in.mode = LOCKING_ANDX_CHANGE_LOCKTYPE;
1531 status = smb_raw_lock(cli->tree, &io);
1532 CHECK_STATUS(status, NT_STATUS_DOS(ERRDOS, ERRnoatomiclocks));
1533
1534 if (smbcli_write(cli->tree, fnum, 0, &c, 100, 1) == 1) {
1535 torture_result(tctx, TORTURE_FAIL,
1536 "allowed write after lock change (%s)\n", __location__);
1537 ret = false;
1538 goto done;
1539 }
1540
1541 done:
1542 smbcli_close(cli->tree, fnum);
1543 smb_raw_exit(cli->session);
1544 smbcli_deltree(cli->tree, BASEDIR);
1545 return ret;
1546 }
1547
1548 struct double_lock_test {
1549 struct smb_lock_entry lock1;
1550 struct smb_lock_entry lock2;
1551 NTSTATUS exp_status;
1552 };
1553
1554 /**
1555 * Tests zero byte locks.
1556 */
1557 static struct double_lock_test zero_byte_tests[] = {
1558 /* {pid, offset, count}, {pid, offset, count}, status */
1559
1560 /** First, takes a zero byte lock at offset 10. Then:
1561 * - Taking 0 byte lock at 10 should succeed.
1562 * - Taking 1 byte locks at 9,10,11 should succeed.
1563 * - Taking 2 byte lock at 9 should fail.
1564 * - Taking 2 byte lock at 10 should succeed.
1565 * - Taking 3 byte lock at 9 should fail.
1566 */
1567 {{1000, 10, 0}, {1001, 10, 0}, NT_STATUS_OK},
1568 {{1000, 10, 0}, {1001, 9, 1}, NT_STATUS_OK},
1569 {{1000, 10, 0}, {1001, 10, 1}, NT_STATUS_OK},
1570 {{1000, 10, 0}, {1001, 11, 1}, NT_STATUS_OK},
1571 {{1000, 10, 0}, {1001, 9, 2}, NT_STATUS_LOCK_NOT_GRANTED},
1572 {{1000, 10, 0}, {1001, 10, 2}, NT_STATUS_OK},
1573 {{1000, 10, 0}, {1001, 9, 3}, NT_STATUS_LOCK_NOT_GRANTED},
1574
1575 /** Same, but opposite order. */
1576 {{1001, 10, 0}, {1000, 10, 0}, NT_STATUS_OK},
1577 {{1001, 9, 1}, {1000, 10, 0}, NT_STATUS_OK},
1578 {{1001, 10, 1}, {1000, 10, 0}, NT_STATUS_OK},
1579 {{1001, 11, 1}, {1000, 10, 0}, NT_STATUS_OK},
1580 {{1001, 9, 2}, {1000, 10, 0}, NT_STATUS_LOCK_NOT_GRANTED},
1581 {{1001, 10, 2}, {1000, 10, 0}, NT_STATUS_OK},
1582 {{1001, 9, 3}, {1000, 10, 0}, NT_STATUS_LOCK_NOT_GRANTED},
1583
1584 /** Zero zero case. */
1585 {{1000, 0, 0}, {1001, 0, 0}, NT_STATUS_OK},
1586 };
1587
1588 static bool test_zerobytelocks(struct torture_context *tctx, struct smbcli_state *cli)
1589 {
1590 union smb_lock io;
1591 NTSTATUS status;
1592 bool ret = true;
1593 int fnum, i;
1594 const char *fname = BASEDIR "\\zero.txt";
1595
1596 torture_comment(tctx, "Testing zero length byte range locks:\n");
1597
1598 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1599
1600 io.generic.level = RAW_LOCK_LOCKX;
1601
1602 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1603 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
1604 "Failed to create %s - %s\n",
1605 fname, smbcli_errstr(cli->tree)));
1606
1607 /* Setup initial parameters */
1608 io.lockx.level = RAW_LOCK_LOCKX;
1609 io.lockx.in.file.fnum = fnum;
1610 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES; /* Exclusive */
1611 io.lockx.in.timeout = 0;
1612
1613 /* Try every combination of locks in zero_byte_tests. The first lock is
1614 * assumed to succeed. The second lock may contend, depending on the
1615 * expected status. */
1616 for (i = 0;
1617 i < ARRAY_SIZE(zero_byte_tests);
1618 i++) {
1619 torture_comment(tctx, " ... {%d, %llu, %llu} + {%d, %llu, %llu} = %s\n",
1620 zero_byte_tests[i].lock1.pid,
1621 (unsigned long long) zero_byte_tests[i].lock1.offset,
1622 (unsigned long long) zero_byte_tests[i].lock1.count,
1623 zero_byte_tests[i].lock2.pid,
1624 (unsigned long long) zero_byte_tests[i].lock2.offset,
1625 (unsigned long long) zero_byte_tests[i].lock2.count,
1626 nt_errstr(zero_byte_tests[i].exp_status));
1627
1628 /* Lock both locks. */
1629 io.lockx.in.ulock_cnt = 0;
1630 io.lockx.in.lock_cnt = 1;
1631
1632 io.lockx.in.locks = discard_const_p(struct smb_lock_entry,
1633 &zero_byte_tests[i].lock1);
1634 status = smb_raw_lock(cli->tree, &io);
1635 CHECK_STATUS(status, NT_STATUS_OK);
1636
1637 io.lockx.in.locks = discard_const_p(struct smb_lock_entry,
1638 &zero_byte_tests[i].lock2);
1639 status = smb_raw_lock(cli->tree, &io);
1640
1641 if (NT_STATUS_EQUAL(zero_byte_tests[i].exp_status,
1642 NT_STATUS_LOCK_NOT_GRANTED)) {
1643 /* Allow either of the failure messages and keep going
1644 * if we see the wrong status. */
1645 CHECK_STATUS_OR_CONT(status,
1646 NT_STATUS_LOCK_NOT_GRANTED,
1647 NT_STATUS_FILE_LOCK_CONFLICT);
1648
1649 } else {
1650 CHECK_STATUS_CONT(status,
1651 zero_byte_tests[i].exp_status);
1652 }
1653
1654 /* Unlock both locks. */
1655 io.lockx.in.ulock_cnt = 1;
1656 io.lockx.in.lock_cnt = 0;
1657
1658 if (NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
1659 status = smb_raw_lock(cli->tree, &io);
1660 CHECK_STATUS(status, NT_STATUS_OK);
1661 }
1662
1663 io.lockx.in.locks = discard_const_p(struct smb_lock_entry,
1664 &zero_byte_tests[i].lock1);
1665 status = smb_raw_lock(cli->tree, &io);
1666 CHECK_STATUS(status, NT_STATUS_OK);
1667 }
1668
1669 done:
1670 smbcli_close(cli->tree, fnum);
1671 smb_raw_exit(cli->session);
1672 smbcli_deltree(cli->tree, BASEDIR);
1673 return ret;
1674 }
1675
1676 static bool test_unlock(struct torture_context *tctx, struct smbcli_state *cli)
1677 {
1678 union smb_lock io;
1679 NTSTATUS status;
1680 bool ret = true;
1681 int fnum1, fnum2;
1682 const char *fname = BASEDIR "\\unlock.txt";
1683 struct smb_lock_entry lock1;
1684 struct smb_lock_entry lock2;
1685
1686 torture_comment(tctx, "Testing LOCKX unlock:\n");
1687
1688 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1689
1690 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1691 torture_assert(tctx,(fnum1 != -1), talloc_asprintf(tctx,
1692 "Failed to create %s - %s\n",
1693 fname, smbcli_errstr(cli->tree)));
1694
1695 fnum2 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1696 torture_assert(tctx,(fnum2 != -1), talloc_asprintf(tctx,
1697 "Failed to create %s - %s\n",
1698 fname, smbcli_errstr(cli->tree)));
1699
1700 /* Setup initial parameters */
1701 io.lockx.level = RAW_LOCK_LOCKX;
1702 io.lockx.in.timeout = 0;
1703
1704 lock1.pid = cli->session->pid;
1705 lock1.offset = 0;
1706 lock1.count = 10;
1707 lock2.pid = cli->session->pid - 1;
1708 lock2.offset = 0;
1709 lock2.count = 10;
1710
1711 /**
1712 * Take exclusive lock, then unlock it with a shared-unlock call.
1713 */
1714 torture_comment(tctx, " taking exclusive lock.\n");
1715 io.lockx.in.ulock_cnt = 0;
1716 io.lockx.in.lock_cnt = 1;
1717 io.lockx.in.mode = 0;
1718 io.lockx.in.file.fnum = fnum1;
1719 io.lockx.in.locks = &lock1;
1720 status = smb_raw_lock(cli->tree, &io);
1721 CHECK_STATUS(status, NT_STATUS_OK);
1722
1723 torture_comment(tctx, " unlock the exclusive with a shared unlock call.\n");
1724 io.lockx.in.ulock_cnt = 1;
1725 io.lockx.in.lock_cnt = 0;
1726 io.lockx.in.mode = LOCKING_ANDX_SHARED_LOCK;
1727 io.lockx.in.file.fnum = fnum1;
1728 io.lockx.in.locks = &lock1;
1729 status = smb_raw_lock(cli->tree, &io);
1730 CHECK_STATUS(status, NT_STATUS_OK);
1731
1732 torture_comment(tctx, " try shared lock on pid2/fnum2, testing the unlock.\n");
1733 io.lockx.in.ulock_cnt = 0;
1734 io.lockx.in.lock_cnt = 1;
1735 io.lockx.in.mode = LOCKING_ANDX_SHARED_LOCK;
1736 io.lockx.in.file.fnum = fnum2;
1737 io.lockx.in.locks = &lock2;
1738 status = smb_raw_lock(cli->tree, &io);
1739 CHECK_STATUS(status, NT_STATUS_OK);
1740
1741 /**
1742 * Unlock a shared lock with an exclusive-unlock call.
1743 */
1744 torture_comment(tctx, " unlock new shared lock with exclusive unlock call.\n");
1745 io.lockx.in.ulock_cnt = 1;
1746 io.lockx.in.lock_cnt = 0;
1747 io.lockx.in.mode = 0;
1748 io.lockx.in.file.fnum = fnum2;
1749 io.lockx.in.locks = &lock2;
1750 status = smb_raw_lock(cli->tree, &io);
1751 CHECK_STATUS(status, NT_STATUS_OK);
1752
1753 torture_comment(tctx, " try exclusive lock on pid1, testing the unlock.\n");
1754 io.lockx.in.ulock_cnt = 0;
1755 io.lockx.in.lock_cnt = 1;
1756 io.lockx.in.mode = 0;
1757 io.lockx.in.file.fnum = fnum1;
1758 io.lockx.in.locks = &lock1;
1759 status = smb_raw_lock(cli->tree, &io);
1760 CHECK_STATUS(status, NT_STATUS_OK);
1761
1762 /* cleanup */
1763 io.lockx.in.ulock_cnt = 1;
1764 io.lockx.in.lock_cnt = 0;
1765 status = smb_raw_lock(cli->tree, &io);
1766 CHECK_STATUS(status, NT_STATUS_OK);
1767
1768 /**
1769 * Test unlocking of 0-byte locks.
1770 */
1771
1772 torture_comment(tctx, " lock shared and exclusive 0-byte locks, testing that Windows "
1773 "always unlocks the exclusive first.\n");
1774 lock1.pid = cli->session->pid;
1775 lock1.offset = 10;
1776 lock1.count = 0;
1777 lock2.pid = cli->session->pid;
1778 lock2.offset = 5;
1779 lock2.count = 10;
1780 io.lockx.in.ulock_cnt = 0;
1781 io.lockx.in.lock_cnt = 1;
1782 io.lockx.in.file.fnum = fnum1;
1783 io.lockx.in.locks = &lock1;
1784
1785 /* lock 0-byte shared
1786 * Note: Order of the shared/exclusive locks doesn't matter. */
1787 io.lockx.in.mode = LOCKING_ANDX_SHARED_LOCK;
1788 status = smb_raw_lock(cli->tree, &io);
1789 CHECK_STATUS(status, NT_STATUS_OK);
1790
1791 /* lock 0-byte exclusive */
1792 io.lockx.in.mode = 0;
1793 status = smb_raw_lock(cli->tree, &io);
1794 CHECK_STATUS(status, NT_STATUS_OK);
1795
1796 /* test contention */
1797 io.lockx.in.mode = LOCKING_ANDX_SHARED_LOCK;
1798 io.lockx.in.locks = &lock2;
1799 io.lockx.in.file.fnum = fnum2;
1800 status = smb_raw_lock(cli->tree, &io);
1801 CHECK_STATUS_OR(status, NT_STATUS_LOCK_NOT_GRANTED,
1802 NT_STATUS_FILE_LOCK_CONFLICT);
1803
1804 /* unlock */
1805 io.lockx.in.ulock_cnt = 1;
1806 io.lockx.in.lock_cnt = 0;
1807 io.lockx.in.file.fnum = fnum1;
1808 io.lockx.in.locks = &lock1;
1809 status = smb_raw_lock(cli->tree, &io);
1810 CHECK_STATUS(status, NT_STATUS_OK);
1811
1812 /* test - can we take a shared lock? */
1813 io.lockx.in.ulock_cnt = 0;
1814 io.lockx.in.lock_cnt = 1;
1815 io.lockx.in.mode = LOCKING_ANDX_SHARED_LOCK;
1816 io.lockx.in.file.fnum = fnum2;
1817 io.lockx.in.locks = &lock2;
1818 status = smb_raw_lock(cli->tree, &io);
1819
1820 /* XXX Samba 3 will fail this test. This is temporary(because this isn't
1821 * new to Win7, it succeeds in WinXP too), until I can come to a
1822 * resolution as to whether Samba should support this or not. There is
1823 * code to preference unlocking exclusive locks before shared locks,
1824 * but its wrapped with "#ifdef ZERO_ZERO". -zkirsch */
1825 if (TARGET_IS_SAMBA3(tctx)) {
1826 CHECK_STATUS_OR(status, NT_STATUS_LOCK_NOT_GRANTED,
1827 NT_STATUS_FILE_LOCK_CONFLICT);
1828 } else {
1829 CHECK_STATUS(status, NT_STATUS_OK);
1830 }
1831
1832 /* cleanup */
1833 io.lockx.in.ulock_cnt = 1;
1834 io.lockx.in.lock_cnt = 0;
1835 status = smb_raw_lock(cli->tree, &io);
1836
1837 /* XXX Same as above. */
1838 if (TARGET_IS_SAMBA3(tctx)) {
1839 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
1840 } else {
1841 CHECK_STATUS(status, NT_STATUS_OK);
1842 }
1843
1844 io.lockx.in.file.fnum = fnum1;
1845 io.lockx.in.locks = &lock1;
1846 status = smb_raw_lock(cli->tree, &io);
1847 CHECK_STATUS(status, NT_STATUS_OK);
1848
1849 done:
1850 smbcli_close(cli->tree, fnum1);
1851 smbcli_close(cli->tree, fnum2);
1852 smb_raw_exit(cli->session);
1853 smbcli_deltree(cli->tree, BASEDIR);
1854 return ret;
1855 }
1856
1857 static bool test_multiple_unlock(struct torture_context *tctx, struct smbcli_state *cli)
1858 {
1859 union smb_lock io;
1860 NTSTATUS status;
1861 bool ret = true;
1862 int fnum1;
1863 const char *fname = BASEDIR "\\unlock_multiple.txt";
1864 struct smb_lock_entry lock1;
1865 struct smb_lock_entry lock2;
1866 struct smb_lock_entry locks[2];
1867
1868 torture_comment(tctx, "Testing LOCKX multiple unlock:\n");
1869
1870 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1871
1872 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1873 torture_assert(tctx,(fnum1 != -1), talloc_asprintf(tctx,
1874 "Failed to create %s - %s\n",
1875 fname, smbcli_errstr(cli->tree)));
1876
1877 /* Setup initial parameters */
1878 io.lockx.level = RAW_LOCK_LOCKX;
1879 io.lockx.in.timeout = 0;
1880
1881 lock1.pid = cli->session->pid;
1882 lock1.offset = 0;
1883 lock1.count = 10;
1884 lock2.pid = cli->session->pid;
1885 lock2.offset = 10;
1886 lock2.count = 10;
1887
1888 locks[0] = lock1;
1889 locks[1] = lock2;
1890
1891 io.lockx.in.file.fnum = fnum1;
1892 io.lockx.in.mode = 0; /* exclusive */
1893
1894 /** Test1: Take second lock, but not first. */
1895 torture_comment(tctx, " unlock 2 locks, first one not locked. Expect no locks "
1896 "unlocked. \n");
1897
1898 io.lockx.in.ulock_cnt = 0;
1899 io.lockx.in.lock_cnt = 1;
1900 io.lockx.in.locks = &lock2;
1901 status = smb_raw_lock(cli->tree, &io);
1902 CHECK_STATUS(status, NT_STATUS_OK);
1903
1904 /* Try to unlock both locks. */
1905 io.lockx.in.ulock_cnt = 2;
1906 io.lockx.in.lock_cnt = 0;
1907 io.lockx.in.locks = locks;
1908
1909 status = smb_raw_lock(cli->tree, &io);
1910 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
1911
1912 /* Second lock should not be unlocked. */
1913 io.lockx.in.ulock_cnt = 0;
1914 io.lockx.in.lock_cnt = 1;
1915 io.lockx.in.locks = &lock2;
1916 status = smb_raw_lock(cli->tree, &io);
1917 CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
1918
1919 /* cleanup */
1920 io.lockx.in.ulock_cnt = 1;
1921 io.lockx.in.lock_cnt = 0;
1922 io.lockx.in.locks = &lock2;
1923 status = smb_raw_lock(cli->tree, &io);
1924 CHECK_STATUS(status, NT_STATUS_OK);
1925
1926 /** Test2: Take first lock, but not second. */
1927 torture_comment(tctx, " unlock 2 locks, second one not locked. Expect first lock "
1928 "unlocked.\n");
1929
1930 io.lockx.in.ulock_cnt = 0;
1931 io.lockx.in.lock_cnt = 1;
1932 io.lockx.in.locks = &lock1;
1933 status = smb_raw_lock(cli->tree, &io);
1934 CHECK_STATUS(status, NT_STATUS_OK);
1935
1936 /* Try to unlock both locks. */
1937 io.lockx.in.ulock_cnt = 2;
1938 io.lockx.in.lock_cnt = 0;
1939 io.lockx.in.locks = locks;
1940
1941 status = smb_raw_lock(cli->tree, &io);
1942 CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
1943
1944 /* First lock should be unlocked. */
1945 io.lockx.in.ulock_cnt = 0;
1946 io.lockx.in.lock_cnt = 1;
1947 io.lockx.in.locks = &lock1;
1948 status = smb_raw_lock(cli->tree, &io);
1949 CHECK_STATUS(status, NT_STATUS_OK);
1950
1951 /* cleanup */
1952 io.lockx.in.ulock_cnt = 1;
1953 io.lockx.in.lock_cnt = 0;
1954 io.lockx.in.locks = &lock1;
1955 status = smb_raw_lock(cli->tree, &io);
1956 CHECK_STATUS(status, NT_STATUS_OK);
1957
1958 /* Test3: Request 2 locks, second will contend. What happens to the
1959 * first? */
1960 torture_comment(tctx, " request 2 locks, second one will contend. "
1961 "Expect both to fail.\n");
1962
1963 /* Lock the second range */
1964 io.lockx.in.ulock_cnt = 0;
1965 io.lockx.in.lock_cnt = 1;
1966 io.lockx.in.locks = &lock2;
1967 status = smb_raw_lock(cli->tree, &io);
1968 CHECK_STATUS(status, NT_STATUS_OK);
1969
1970 /* Request both locks */
1971 io.lockx.in.ulock_cnt = 0;
1972 io.lockx.in.lock_cnt = 2;
1973 io.lockx.in.locks = locks;
1974
1975 status = smb_raw_lock(cli->tree, &io);
1976 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
1977
1978 /* First lock should be unlocked. */
1979 io.lockx.in.ulock_cnt = 0;
1980 io.lockx.in.lock_cnt = 1;
1981 io.lockx.in.locks = &lock1;
1982 status = smb_raw_lock(cli->tree, &io);
1983 CHECK_STATUS(status, NT_STATUS_OK);
1984
1985 /* cleanup */
1986 io.lockx.in.ulock_cnt = 2;
1987 io.lockx.in.lock_cnt = 0;
1988 io.lockx.in.locks = locks;
1989 status = smb_raw_lock(cli->tree, &io);
1990 CHECK_STATUS(status, NT_STATUS_OK);
1991
1992 /* Test4: Request unlock and lock. The lock contends, is the unlock
1993 * then re-locked? */
1994 torture_comment(tctx, " request unlock and lock, second one will "
1995 "contend. Expect the unlock to succeed.\n");
1996
1997 /* Lock both ranges */
1998 io.lockx.in.ulock_cnt = 0;
1999 io.lockx.in.lock_cnt = 2;
2000 io.lockx.in.locks = locks;
2001 status = smb_raw_lock(cli->tree, &io);
2002 CHECK_STATUS(status, NT_STATUS_OK);
2003
2004 /* Attempt to unlock the first range and lock the second */
2005 io.lockx.in.ulock_cnt = 1;
2006 io.lockx.in.lock_cnt = 1;
2007 io.lockx.in.locks = locks;
2008 status = smb_raw_lock(cli->tree, &io);
2009 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
2010
2011 /* The first lock should've been unlocked */
2012 io.lockx.in.ulock_cnt = 0;
2013 io.lockx.in.lock_cnt = 1;
2014 io.lockx.in.locks = &lock1;
2015 status = smb_raw_lock(cli->tree, &io);
2016 CHECK_STATUS(status, NT_STATUS_OK);
2017
2018 /* cleanup */
2019 io.lockx.in.ulock_cnt = 2;
2020 io.lockx.in.lock_cnt = 0;
2021 io.lockx.in.locks = locks;
2022 status = smb_raw_lock(cli->tree, &io);
2023 CHECK_STATUS(status, NT_STATUS_OK);
2024
2025 done:
2026 smbcli_close(cli->tree, fnum1);
2027 smb_raw_exit(cli->session);
2028 smbcli_deltree(cli->tree, BASEDIR);
2029 return ret;
2030 }
2031
2032 /**
2033 * torture_locktest5 covers stacking pretty well, but its missing two tests:
2034 * - stacking an exclusive on top of shared fails
2035 * - stacking two exclusives fail
2036 */
2037 static bool test_stacking(struct torture_context *tctx, struct smbcli_state *cli)
2038 {
2039 union smb_lock io;
2040 NTSTATUS status;
2041 bool ret = true;
2042 int fnum1;
2043 const char *fname = BASEDIR "\\stacking.txt";
2044 struct smb_lock_entry lock1;
2045
2046 torture_comment(tctx, "Testing stacking:\n");
2047
2048 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
2049
2050 io.generic.level = RAW_LOCK_LOCKX;
2051
2052 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2053 torture_assert(tctx,(fnum1 != -1), talloc_asprintf(tctx,
2054 "Failed to create %s - %s\n",
2055 fname, smbcli_errstr(cli->tree)));
2056
2057 /* Setup initial parameters */
2058 io.lockx.level = RAW_LOCK_LOCKX;
2059 io.lockx.in.timeout = 0;
2060
2061 lock1.pid = cli->session->pid;
2062 lock1.offset = 0;
2063 lock1.count = 10;
2064
2065 /**
2066 * Try to take a shared lock, then stack an exclusive.
2067 */
2068 torture_comment(tctx, " stacking an exclusive on top of a shared lock fails.\n");
2069 io.lockx.in.file.fnum = fnum1;
2070 io.lockx.in.locks = &lock1;
2071
2072 io.lockx.in.ulock_cnt = 0;
2073 io.lockx.in.lock_cnt = 1;
2074 io.lockx.in.mode = LOCKING_ANDX_SHARED_LOCK;
2075 status = smb_raw_lock(cli->tree, &io);
2076 CHECK_STATUS(status, NT_STATUS_OK);
2077
2078 io.lockx.in.ulock_cnt = 0;
2079 io.lockx.in.lock_cnt = 1;
2080 io.lockx.in.mode = 0;
2081 status = smb_raw_lock(cli->tree, &io);
2082 CHECK_STATUS_OR(status, NT_STATUS_LOCK_NOT_GRANTED,
2083 NT_STATUS_FILE_LOCK_CONFLICT);
2084
2085 /* cleanup */
2086 io.lockx.in.ulock_cnt = 1;
2087 io.lockx.in.lock_cnt = 0;
2088 status = smb_raw_lock(cli->tree, &io);
2089 CHECK_STATUS(status, NT_STATUS_OK);
2090
2091 /**
2092 * Prove that two exclusive locks do not stack.
2093 */
2094 torture_comment(tctx, " two exclusive locks do not stack.\n");
2095 io.lockx.in.ulock_cnt = 0;
2096 io.lockx.in.lock_cnt = 1;
2097 io.lockx.in.mode = 0;
2098 status = smb_raw_lock(cli->tree, &io);
2099 CHECK_STATUS(status, NT_STATUS_OK);
2100 status = smb_raw_lock(cli->tree, &io);
2101 CHECK_STATUS_OR(status, NT_STATUS_LOCK_NOT_GRANTED,
2102 NT_STATUS_FILE_LOCK_CONFLICT);
2103
2104 /* cleanup */
2105 io.lockx.in.ulock_cnt = 1;
2106 io.lockx.in.lock_cnt = 0;
2107 status = smb_raw_lock(cli->tree, &io);
2108 CHECK_STATUS(status, NT_STATUS_OK);
2109
2110 done:
2111 smbcli_close(cli->tree, fnum1);
2112 smb_raw_exit(cli->session);
2113 smbcli_deltree(cli->tree, BASEDIR);
2114 return ret;
2115 }
2116
2117 /**
2118 * Test how 0-byte read requests contend with byte range locks
2119 */
2120 static bool test_zerobyteread(struct torture_context *tctx,
2121 struct smbcli_state *cli)
2122 {
2123 union smb_lock io;
2124 union smb_read rd;
2125 NTSTATUS status;
2126 bool ret = true;
2127 int fnum1, fnum2;
2128 const char *fname = BASEDIR "\\zerobyteread.txt";
2129 struct smb_lock_entry lock1;
2130 uint8_t c = 1;
2131
2132 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
2133
2134 io.generic.level = RAW_LOCK_LOCKX;
2135
2136 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2137 torture_assert(tctx,(fnum1 != -1), talloc_asprintf(tctx,
2138 "Failed to create %s - %s\n",
2139 fname, smbcli_errstr(cli->tree)));
2140
2141 fnum2 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2142 torture_assert(tctx,(fnum2 != -1), talloc_asprintf(tctx,
2143 "Failed to create %s - %s\n",
2144 fname, smbcli_errstr(cli->tree)));
2145
2146 /* Setup initial parameters */
2147 io.lockx.level = RAW_LOCK_LOCKX;
2148 io.lockx.in.timeout = 0;
2149
2150 lock1.pid = cli->session->pid;
2151 lock1.offset = 0;
2152 lock1.count = 10;
2153
2154 ZERO_STRUCT(rd);
2155 rd.readx.level = RAW_READ_READX;
2156
2157 torture_comment(tctx, "Testing zero byte read on lock range:\n");
2158
2159 /* Take an exclusive lock */
2160 torture_comment(tctx, " taking exclusive lock.\n");
2161 io.lockx.in.ulock_cnt = 0;
2162 io.lockx.in.lock_cnt = 1;
2163 io.lockx.in.mode = LOCKING_ANDX_EXCLUSIVE_LOCK;
2164 io.lockx.in.file.fnum = fnum1;
2165 io.lockx.in.locks = &lock1;
2166 status = smb_raw_lock(cli->tree, &io);
2167 CHECK_STATUS(status, NT_STATUS_OK);
2168
2169 /* Try a zero byte read */
2170 torture_comment(tctx, " reading 0 bytes.\n");
2171 rd.readx.in.file.fnum = fnum2;
2172 rd.readx.in.offset = 5;
2173 rd.readx.in.mincnt = 0;
2174 rd.readx.in.maxcnt = 0;
2175 rd.readx.in.remaining = 0;
2176 rd.readx.in.read_for_execute = false;
2177 rd.readx.out.data = &c;
2178 status = smb_raw_read(cli->tree, &rd);
2179 torture_assert_int_equal_goto(tctx, rd.readx.out.nread, 0, ret, done,
2180 "zero byte read did not return 0 bytes");
2181 CHECK_STATUS(status, NT_STATUS_OK);
2182
2183 /* Unlock lock */
2184 io.lockx.in.ulock_cnt = 1;
2185 io.lockx.in.lock_cnt = 0;
2186 io.lockx.in.mode = LOCKING_ANDX_EXCLUSIVE_LOCK;
2187 io.lockx.in.file.fnum = fnum1;
2188 io.lockx.in.locks = &lock1;
2189 status = smb_raw_lock(cli->tree, &io);
2190 CHECK_STATUS(status, NT_STATUS_OK);
2191
2192 torture_comment(tctx, "Testing zero byte read on zero byte lock "
2193 "range:\n");
2194
2195 /* Take an exclusive lock */
2196 torture_comment(tctx, " taking exclusive 0-byte lock.\n");
2197 io.lockx.in.ulock_cnt = 0;
2198 io.lockx.in.lock_cnt = 1;
2199 io.lockx.in.mode = LOCKING_ANDX_EXCLUSIVE_LOCK;
2200 io.lockx.in.file.fnum = fnum1;
2201 io.lockx.in.locks = &lock1;
2202 lock1.offset = 5;
2203 lock1.count = 0;
2204 status = smb_raw_lock(cli->tree, &io);
2205 CHECK_STATUS(status, NT_STATUS_OK);
2206
2207 /* Try a zero byte read before the lock */
2208 torture_comment(tctx, " reading 0 bytes before the lock.\n");
2209 rd.readx.in.file.fnum = fnum2;
2210 rd.readx.in.offset = 4;
2211 rd.readx.in.mincnt = 0;
2212 rd.readx.in.maxcnt = 0;
2213 rd.readx.in.remaining = 0;
2214 rd.readx.in.read_for_execute = false;
2215 rd.readx.out.data = &c;
2216 status = smb_raw_read(cli->tree, &rd);
2217 torture_assert_int_equal_goto(tctx, rd.readx.out.nread, 0, ret, done,
2218 "zero byte read did not return 0 bytes");
2219 CHECK_STATUS(status, NT_STATUS_OK);
2220
2221 /* Try a zero byte read on the lock */
2222 torture_comment(tctx, " reading 0 bytes on the lock.\n");
2223 rd.readx.in.file.fnum = fnum2;
2224 rd.readx.in.offset = 5;
2225 rd.readx.in.mincnt = 0;
2226 rd.readx.in.maxcnt = 0;
2227 rd.readx.in.remaining = 0;
2228 rd.readx.in.read_for_execute = false;
2229 rd.readx.out.data = &c;
2230 status = smb_raw_read(cli->tree, &rd);
2231 torture_assert_int_equal_goto(tctx, rd.readx.out.nread, 0, ret, done,
2232 "zero byte read did not return 0 bytes");
2233 CHECK_STATUS(status, NT_STATUS_OK);
2234
2235 /* Try a zero byte read after the lock */
2236 torture_comment(tctx, " reading 0 bytes after the lock.\n");
2237 rd.readx.in.file.fnum = fnum2;
2238 rd.readx.in.offset = 6;
2239 rd.readx.in.mincnt = 0;
2240 rd.readx.in.maxcnt = 0;
2241 rd.readx.in.remaining = 0;
2242 rd.readx.in.read_for_execute = false;
2243 rd.readx.out.data = &c;
2244 status = smb_raw_read(cli->tree, &rd);
2245 torture_assert_int_equal_goto(tctx, rd.readx.out.nread, 0, ret, done,
2246 "zero byte read did not return 0 bytes");
2247 CHECK_STATUS(status, NT_STATUS_OK);
2248
2249 /* Unlock lock */
2250 io.lockx.in.ulock_cnt = 1;
2251 io.lockx.in.lock_cnt = 0;
2252 io.lockx.in.mode = LOCKING_ANDX_EXCLUSIVE_LOCK;
2253 io.lockx.in.file.fnum = fnum1;
2254 io.lockx.in.locks = &lock1;
2255 status = smb_raw_lock(cli->tree, &io);
2256 CHECK_STATUS(status, NT_STATUS_OK);
2257
2258 done:
2259 smbcli_close(cli->tree, fnum1);
2260 smbcli_close(cli->tree, fnum2);
2261 smb_raw_exit(cli->session);
2262 smbcli_deltree(cli->tree, BASEDIR);
2263 return ret;
2264 }
2265 /*
2266 test multi Locking&X operation
2267 */
2268 static bool test_multilock(struct torture_context *tctx,
2269 struct smbcli_state *cli)
2270 {
2271 union smb_lock io;
2272 struct smb_lock_entry lock[2];
2273 NTSTATUS status;
2274 bool ret = true;
2275 int fnum;
2276 const char *fname = BASEDIR "\\multilock_test.txt";
2277 time_t t;
2278 struct smbcli_request *req;
2279 struct smbcli_session_options options;
2280
2281 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
2282
2283 lpcfg_smbcli_session_options(tctx->lp_ctx, &options);
2284
2285 torture_comment(tctx, "Testing LOCKING_ANDX multi-lock\n");
2286 io.generic.level = RAW_LOCK_LOCKX;
2287
2288 /* Create the test file. */
2289 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2290 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
2291 "Failed to create %s - %s\n",
2292 fname, smbcli_errstr(cli->tree)));
2293
2294 /*
2295 * Lock regions 100->109, 120->129 as
2296 * two separate write locks in one request.
2297 */
2298 io.lockx.level = RAW_LOCK_LOCKX;
2299 io.lockx.in.file.fnum = fnum;
2300 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
2301 io.lockx.in.timeout = 0;
2302 io.lockx.in.ulock_cnt = 0;
2303 io.lockx.in.lock_cnt = 2;
2304 io.lockx.in.mode = LOCKING_ANDX_EXCLUSIVE_LOCK;
2305 lock[0].pid = cli->session->pid;
2306 lock[0].offset = 100;
2307 lock[0].count = 10;
2308 lock[1].pid = cli->session->pid;
2309 lock[1].offset = 120;
2310 lock[1].count = 10;
2311 io.lockx.in.locks = &lock[0];
2312 status = smb_raw_lock(cli->tree, &io);
2313 CHECK_STATUS(status, NT_STATUS_OK);
2314
2315 /*
2316 * Now request the same locks on a different
2317 * context as blocking locks with infinite timeout.
2318 */
2319
2320 io.lockx.in.timeout = 20000;
2321 lock[0].pid = cli->session->pid+1;
2322 lock[1].pid = cli->session->pid+1;
2323 req = smb_raw_lock_send(cli->tree, &io);
2324 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
2325 "Failed to setup timed locks (%s)\n", __location__));
2326
2327 /* Unlock lock[0] */
2328 io.lockx.in.timeout = 0;
2329 io.lockx.in.ulock_cnt = 1;
2330 io.lockx.in.lock_cnt = 0;
2331 io.lockx.in.locks = &lock[0];
2332 lock[0].pid = cli->session->pid;
2333 status = smb_raw_lock(cli->tree, &io);
2334 CHECK_STATUS(status, NT_STATUS_OK);
2335
2336 /* Start the clock. */
2337 t = time_mono(NULL);
2338
2339 /* Unlock lock[1] */
2340 io.lockx.in.timeout = 0;
2341 io.lockx.in.ulock_cnt = 1;
2342 io.lockx.in.lock_cnt = 0;
2343 io.lockx.in.locks = &lock[1];
2344 lock[1].pid = cli->session->pid;
2345 status = smb_raw_lock(cli->tree, &io);
2346 CHECK_STATUS(status, NT_STATUS_OK);
2347
2348 /* receive the successful blocked lock requests */
2349 status = smbcli_request_simple_recv(req);
2350 CHECK_STATUS(status, NT_STATUS_OK);
2351
2352 /* Fail if this took more than 2 seconds. */
2353 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
2354 "Blocking locks were not granted immediately (%s)\n",
2355 __location__));
2356 done:
2357 smb_raw_exit(cli->session);
2358 smbcli_deltree(cli->tree, BASEDIR);
2359 return ret;
2360 }
2361
2362 /*
2363 test multi2 Locking&X operation
2364 This test is designed to show that
2365 lock precedence on the server is based
2366 on the order received, not on the ability
2367 to grant. For example:
2368
2369 A blocked lock request containing 2 locks
2370 will be satified before a subsequent blocked
2371 lock request over one of the same regions,
2372 even if that region is then unlocked. E.g.
2373
2374 (a) lock 100->109, 120->129 (granted)
2375 (b) lock 100->109, 120-129 (blocks)
2376 (c) lock 100->109 (blocks)
2377 (d) unlock 100->109
2378
2379 lock (c) will not be granted as lock (b)
2380 will take precedence.
2381 */
2382 static bool test_multilock2(struct torture_context *tctx,
2383 struct smbcli_state *cli)
2384 {
2385 union smb_lock io;
2386 struct smb_lock_entry lock[2];
2387 NTSTATUS status;
2388 bool ret = true;
2389 int fnum;
2390 const char *fname = BASEDIR "\\multilock2_test.txt";
2391 time_t t;
2392 struct smbcli_request *req;
2393 struct smbcli_request *req2;
2394 struct smbcli_session_options options;
2395
2396 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
2397
2398 lpcfg_smbcli_session_options(tctx->lp_ctx, &options);
2399
2400 torture_comment(tctx, "Testing LOCKING_ANDX multi-lock 2\n");
2401 io.generic.level = RAW_LOCK_LOCKX;
2402
2403 /* Create the test file. */
2404 fnum = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2405 torture_assert(tctx,(fnum != -1), talloc_asprintf(tctx,
2406 "Failed to create %s - %s\n",
2407 fname, smbcli_errstr(cli->tree)));
2408
2409 /*
2410 * Lock regions 100->109, 120->129 as
2411 * two separate write locks in one request.
2412 */
2413 io.lockx.level = RAW_LOCK_LOCKX;
2414 io.lockx.in.file.fnum = fnum;
2415 io.lockx.in.mode = LOCKING_ANDX_LARGE_FILES;
2416 io.lockx.in.timeout = 0;
2417 io.lockx.in.ulock_cnt = 0;
2418 io.lockx.in.lock_cnt = 2;
2419 io.lockx.in.mode = LOCKING_ANDX_EXCLUSIVE_LOCK;
2420 lock[0].pid = cli->session->pid;
2421 lock[0].offset = 100;
2422 lock[0].count = 10;
2423 lock[1].pid = cli->session->pid;
2424 lock[1].offset = 120;
2425 lock[1].count = 10;
2426 io.lockx.in.locks = &lock[0];
2427 status = smb_raw_lock(cli->tree, &io);
2428 CHECK_STATUS(status, NT_STATUS_OK);
2429
2430 /*
2431 * Now request the same locks on a different
2432 * context as blocking locks.
2433 */
2434
2435 io.lockx.in.timeout = 20000;
2436 lock[0].pid = cli->session->pid+1;
2437 lock[1].pid = cli->session->pid+1;
2438 req = smb_raw_lock_send(cli->tree, &io);
2439 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
2440 "Failed to setup timed locks (%s)\n", __location__));
2441
2442 /*
2443 * Request the first lock again on a separate context.
2444 * Wait 2 seconds. This should time out (the previous
2445 * multi-lock request should take precedence).
2446 */
2447
2448 io.lockx.in.timeout = 2000;
2449 lock[0].pid = cli->session->pid+2;
2450 io.lockx.in.lock_cnt = 1;
2451 req2 = smb_raw_lock_send(cli->tree, &io);
2452 torture_assert(tctx,(req != NULL), talloc_asprintf(tctx,
2453 "Failed to setup timed locks (%s)\n", __location__));
2454
2455 /* Unlock lock[0] */
2456 io.lockx.in.timeout = 0;
2457 io.lockx.in.ulock_cnt = 1;
2458 io.lockx.in.lock_cnt = 0;
2459 io.lockx.in.locks = &lock[0];
2460 lock[0].pid = cli->session->pid;
2461 status = smb_raw_lock(cli->tree, &io);
2462 CHECK_STATUS(status, NT_STATUS_OK);
2463
2464 /* Did the second lock complete (should time out) ? */
2465 status = smbcli_request_simple_recv(req2);
2466 CHECK_STATUS(status, NT_STATUS_FILE_LOCK_CONFLICT);
2467
2468 /* Start the clock. */
2469 t = time_mono(NULL);
2470
2471 /* Unlock lock[1] */
2472 io.lockx.in.timeout = 0;
2473 io.lockx.in.ulock_cnt = 1;
2474 io.lockx.in.lock_cnt = 0;
2475 io.lockx.in.locks = &lock[1];
2476 lock[1].pid = cli->session->pid;
2477 status = smb_raw_lock(cli->tree, &io);
2478 CHECK_STATUS(status, NT_STATUS_OK);
2479
2480 /* receive the successful blocked lock requests */
2481 status = smbcli_request_simple_recv(req);
2482 CHECK_STATUS(status, NT_STATUS_OK);
2483
2484 /* Fail if this took more than 2 seconds. */
2485 torture_assert(tctx,!(time_mono(NULL) > t+2), talloc_asprintf(tctx,
2486 "Blocking locks were not granted immediately (%s)\n",
2487 __location__));
2488 done:
2489 smb_raw_exit(cli->session);
2490 smbcli_deltree(cli->tree, BASEDIR);
2491 return ret;
2492 }
2493
2494
2495 /*
2496 basic testing of lock calls
2497 */
2498 struct torture_suite *torture_raw_lock(TALLOC_CTX *mem_ctx)
2499 {
2500 struct torture_suite *suite = torture_suite_create(mem_ctx, "lock");
2501
2502 torture_suite_add_1smb_test(suite, "lockx", test_lockx);
2503 torture_suite_add_1smb_test(suite, "lock", test_lock);
2504 torture_suite_add_1smb_test(suite, "pidhigh", test_pidhigh);
2505 torture_suite_add_1smb_test(suite, "async", test_async);
2506 torture_suite_add_1smb_test(suite, "errorcode", test_errorcode);
2507 torture_suite_add_1smb_test(suite, "changetype", test_changetype);
2508
2509 torture_suite_add_1smb_test(suite, "stacking", test_stacking);
2510 torture_suite_add_1smb_test(suite, "unlock", test_unlock);
2511 torture_suite_add_1smb_test(suite, "multiple_unlock",
2512 test_multiple_unlock);
2513 torture_suite_add_1smb_test(suite, "zerobytelocks", test_zerobytelocks);
2514 torture_suite_add_1smb_test(suite, "zerobyteread", test_zerobyteread);
2515 torture_suite_add_1smb_test(suite, "multilock", test_multilock);
2516 torture_suite_add_1smb_test(suite, "multilock2", test_multilock2);
2517
2518 return suite;
2519 }
Samba GIT mirror