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