2 Unix SMB/CIFS implementation.
3 basic raw test suite for oplocks
4 Copyright (C) Andrew Tridgell 2003
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 2 of the License, or
9 (at your option) any later version.
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.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include "torture/torture.h"
23 #include "librpc/gen_ndr/security.h"
24 #include "libcli/raw/libcliraw.h"
25 #include "libcli/libcli.h"
26 #include "torture/util.h"
28 #define CHECK_VAL(v, correct) do { \
29 if ((v) != (correct)) { \
30 printf("(%d) wrong value for %s got 0x%x - should be 0x%x\n", \
31 __LINE__, #v, (int)v, (int)correct); \
35 #define CHECK_STATUS(status, correct) do { \
36 if (!NT_STATUS_EQUAL(status, correct)) { \
37 printf("(%d) Incorrect status %s - should be %s\n", \
38 __LINE__, nt_errstr(status), nt_errstr(correct)); \
52 a handler function for oplock break requests
54 static BOOL oplock_handler_ack(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private)
56 struct smbcli_tree *tree = private;
57 break_info.fnum = fnum;
58 break_info.level = level;
61 printf("Acking in oplock handler\n");
63 return smbcli_oplock_ack(tree, fnum, level);
66 static void oplock_handler_close_recv(struct smbcli_request *req)
69 status = smbcli_request_simple_recv(req);
70 if (!NT_STATUS_IS_OK(status)) {
71 printf("close failed in oplock_handler_close\n");
72 break_info.failures++;
77 a handler function for oplock break requests - close the file
79 static BOOL oplock_handler_close(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *private)
82 struct smbcli_tree *tree = private;
83 struct smbcli_request *req;
85 break_info.fnum = fnum;
86 break_info.level = level;
89 printf("Closing in oplock handler\n");
91 io.close.level = RAW_CLOSE_CLOSE;
92 io.close.in.file.fnum = fnum;
93 io.close.in.write_time = 0;
94 req = smb_raw_close_send(tree, &io);
96 printf("failed to send close in oplock_handler_close\n");
100 req->async.fn = oplock_handler_close_recv;
101 req->async.private = NULL;
109 static BOOL test_oplock(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
111 const char *fname = "\\test_oplock.dat";
115 union smb_unlink unl;
117 uint16_t fnum=0, fnum2=0;
120 smbcli_unlink(cli->tree, fname);
122 smbcli_oplock_handler(cli->transport, oplock_handler_ack, cli->tree);
127 io.generic.level = RAW_OPEN_NTCREATEX;
128 io.ntcreatex.in.root_fid = 0;
129 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
130 io.ntcreatex.in.alloc_size = 0;
131 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
132 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
133 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
134 io.ntcreatex.in.create_options = 0;
135 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
136 io.ntcreatex.in.security_flags = 0;
137 io.ntcreatex.in.fname = fname;
139 printf("open a file with a normal oplock\n");
140 ZERO_STRUCT(break_info);
141 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | NTCREATEX_FLAGS_REQUEST_OPLOCK;
143 status = smb_raw_open(cli->tree, mem_ctx, &io);
144 CHECK_STATUS(status, NT_STATUS_OK);
145 fnum = io.ntcreatex.out.file.fnum;
146 CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
148 printf("unlink it - should be no break\n");
149 unl.unlink.in.pattern = fname;
150 unl.unlink.in.attrib = 0;
151 status = smb_raw_unlink(cli->tree, &unl);
152 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
153 CHECK_VAL(break_info.count, 0);
154 CHECK_VAL(break_info.failures, 0);
156 smbcli_close(cli->tree, fnum);
159 with a batch oplock we get a break
161 printf("open with batch oplock\n");
162 ZERO_STRUCT(break_info);
163 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
164 NTCREATEX_FLAGS_REQUEST_OPLOCK |
165 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
166 status = smb_raw_open(cli->tree, mem_ctx, &io);
167 CHECK_STATUS(status, NT_STATUS_OK);
168 fnum = io.ntcreatex.out.file.fnum;
169 CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
171 printf("unlink should generate a break\n");
172 unl.unlink.in.pattern = fname;
173 unl.unlink.in.attrib = 0;
174 status = smb_raw_unlink(cli->tree, &unl);
175 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
177 CHECK_VAL(break_info.fnum, fnum);
178 CHECK_VAL(break_info.level, 1);
179 CHECK_VAL(break_info.count, 1);
180 CHECK_VAL(break_info.failures, 0);
182 smbcli_close(cli->tree, fnum);
184 printf("if we close on break then the unlink can succeed\n");
185 ZERO_STRUCT(break_info);
186 smbcli_oplock_handler(cli->transport, oplock_handler_close, cli->tree);
187 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
188 NTCREATEX_FLAGS_REQUEST_OPLOCK |
189 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
190 status = smb_raw_open(cli->tree, mem_ctx, &io);
191 CHECK_STATUS(status, NT_STATUS_OK);
192 fnum = io.ntcreatex.out.file.fnum;
193 CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
195 unl.unlink.in.pattern = fname;
196 unl.unlink.in.attrib = 0;
197 ZERO_STRUCT(break_info);
198 status = smb_raw_unlink(cli->tree, &unl);
199 CHECK_STATUS(status, NT_STATUS_OK);
201 CHECK_VAL(break_info.fnum, fnum);
202 CHECK_VAL(break_info.level, 1);
203 CHECK_VAL(break_info.count, 1);
204 CHECK_VAL(break_info.failures, 0);
206 printf("a self read should not cause a break\n");
207 ZERO_STRUCT(break_info);
208 smbcli_close(cli->tree, fnum);
209 smbcli_oplock_handler(cli->transport, oplock_handler_ack, cli->tree);
211 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
212 NTCREATEX_FLAGS_REQUEST_OPLOCK |
213 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
214 status = smb_raw_open(cli->tree, mem_ctx, &io);
215 CHECK_STATUS(status, NT_STATUS_OK);
216 fnum = io.ntcreatex.out.file.fnum;
217 CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
219 rd.read.level = RAW_READ_READ;
220 rd.read.in.file.fnum = fnum;
221 rd.read.in.count = 1;
222 rd.read.in.offset = 0;
223 rd.read.in.remaining = 0;
224 status = smb_raw_read(cli->tree, &rd);
225 CHECK_STATUS(status, NT_STATUS_OK);
226 CHECK_VAL(break_info.count, 0);
227 CHECK_VAL(break_info.failures, 0);
229 printf("a 2nd open should give a break\n");
230 ZERO_STRUCT(break_info);
231 smbcli_close(cli->tree, fnum);
232 smbcli_oplock_handler(cli->transport, oplock_handler_ack, cli->tree);
234 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
235 NTCREATEX_FLAGS_REQUEST_OPLOCK |
236 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
237 status = smb_raw_open(cli->tree, mem_ctx, &io);
238 CHECK_STATUS(status, NT_STATUS_OK);
239 fnum = io.ntcreatex.out.file.fnum;
240 CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
242 ZERO_STRUCT(break_info);
244 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
245 status = smb_raw_open(cli->tree, mem_ctx, &io);
246 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
248 CHECK_VAL(break_info.count, 1);
249 CHECK_VAL(break_info.fnum, fnum);
250 CHECK_VAL(break_info.level, 1);
251 CHECK_VAL(break_info.failures, 0);
253 printf("a 2nd open should get an oplock when we close instead of ack\n");
254 ZERO_STRUCT(break_info);
255 smbcli_close(cli->tree, fnum);
256 smbcli_oplock_handler(cli->transport, oplock_handler_close, cli->tree);
258 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
259 NTCREATEX_FLAGS_REQUEST_OPLOCK |
260 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
261 status = smb_raw_open(cli->tree, mem_ctx, &io);
262 CHECK_STATUS(status, NT_STATUS_OK);
263 fnum2 = io.ntcreatex.out.file.fnum;
264 CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
266 ZERO_STRUCT(break_info);
268 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
269 NTCREATEX_FLAGS_REQUEST_OPLOCK |
270 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
271 status = smb_raw_open(cli->tree, mem_ctx, &io);
272 CHECK_STATUS(status, NT_STATUS_OK);
273 fnum = io.ntcreatex.out.file.fnum;
274 CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
276 CHECK_VAL(break_info.count, 1);
277 CHECK_VAL(break_info.fnum, fnum2);
278 CHECK_VAL(break_info.level, 1);
279 CHECK_VAL(break_info.failures, 0);
281 smbcli_close(cli->tree, fnum);
283 printf("open with batch oplock\n");
284 ZERO_STRUCT(break_info);
285 smbcli_oplock_handler(cli->transport, oplock_handler_ack, cli->tree);
287 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
288 NTCREATEX_FLAGS_REQUEST_OPLOCK |
289 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
290 status = smb_raw_open(cli->tree, mem_ctx, &io);
291 CHECK_STATUS(status, NT_STATUS_OK);
292 fnum = io.ntcreatex.out.file.fnum;
293 CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
295 ZERO_STRUCT(break_info);
296 printf("second open with attributes only shouldn't cause oplock break\n");
298 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
299 NTCREATEX_FLAGS_REQUEST_OPLOCK |
300 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
301 io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
302 status = smb_raw_open(cli->tree, mem_ctx, &io);
303 CHECK_STATUS(status, NT_STATUS_OK);
304 fnum2 = io.ntcreatex.out.file.fnum;
305 CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
306 CHECK_VAL(break_info.count, 0);
307 CHECK_VAL(break_info.fnum, 0);
308 CHECK_VAL(break_info.level, 0);
309 CHECK_VAL(break_info.failures, 0);
311 smbcli_close(cli->tree, fnum);
312 smbcli_close(cli->tree, fnum2);
313 smbcli_unlink(cli->tree, fname);
315 printf("open with attributes only can create file\n");
316 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
317 NTCREATEX_FLAGS_REQUEST_OPLOCK |
318 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
319 io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
320 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
321 status = smb_raw_open(cli->tree, mem_ctx, &io);
322 CHECK_STATUS(status, NT_STATUS_OK);
323 fnum = io.ntcreatex.out.file.fnum;
324 CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
326 printf("Subsequent normal open should break oplock on attribute only open to level II\n");
328 ZERO_STRUCT(break_info);
329 smbcli_oplock_handler(cli->transport, oplock_handler_ack, cli->tree);
331 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
332 NTCREATEX_FLAGS_REQUEST_OPLOCK |
333 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
334 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
335 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
336 status = smb_raw_open(cli->tree, mem_ctx, &io);
337 CHECK_STATUS(status, NT_STATUS_OK);
338 fnum2 = io.ntcreatex.out.file.fnum;
339 CHECK_VAL(break_info.count, 1);
340 CHECK_VAL(break_info.fnum, fnum);
341 CHECK_VAL(break_info.failures, 0);
342 CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
343 smbcli_close(cli->tree, fnum2);
345 printf("third oplocked open should grant level2 without break\n");
346 ZERO_STRUCT(break_info);
347 smbcli_oplock_handler(cli->transport, oplock_handler_ack, cli->tree);
348 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
349 NTCREATEX_FLAGS_REQUEST_OPLOCK |
350 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
351 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
352 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
353 status = smb_raw_open(cli->tree, mem_ctx, &io);
354 CHECK_STATUS(status, NT_STATUS_OK);
355 fnum2 = io.ntcreatex.out.file.fnum;
356 CHECK_VAL(break_info.count, 0);
357 CHECK_VAL(break_info.failures, 0);
358 CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
360 ZERO_STRUCT(break_info);
362 printf("write should trigger a break to none on both\n");
365 wr.write.level = RAW_WRITE_WRITE;
366 wr.write.in.file.fnum = fnum2;
367 wr.write.in.count = 1;
368 wr.write.in.offset = 0;
369 wr.write.in.remaining = 0;
370 wr.write.in.data = (const uint8_t *)"x";
371 status = smb_raw_write(cli->tree, &wr);
372 CHECK_STATUS(status, NT_STATUS_OK);
375 /* Now the oplock break request comes in. But right now we can't
376 * answer it. Do another write */
382 wr.write.level = RAW_WRITE_WRITE;
383 wr.write.in.file.fnum = fnum2;
384 wr.write.in.count = 1;
385 wr.write.in.offset = 0;
386 wr.write.in.remaining = 0;
387 wr.write.in.data = (const uint8_t *)"x";
388 status = smb_raw_write(cli->tree, &wr);
389 CHECK_STATUS(status, NT_STATUS_OK);
392 CHECK_VAL(break_info.count, 2);
393 CHECK_VAL(break_info.level, 0);
394 CHECK_VAL(break_info.failures, 0);
396 smbcli_close(cli->tree, fnum);
397 smbcli_close(cli->tree, fnum2);
399 ZERO_STRUCT(break_info);
400 smbcli_oplock_handler(cli->transport, oplock_handler_ack, cli->tree);
402 printf("Open with oplock after a on-oplock open should grant level2\n");
403 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
404 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
405 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
406 NTCREATEX_SHARE_ACCESS_WRITE|
407 NTCREATEX_SHARE_ACCESS_DELETE;
408 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
409 status = smb_raw_open(cli->tree, mem_ctx, &io);
410 CHECK_STATUS(status, NT_STATUS_OK);
411 fnum = io.ntcreatex.out.file.fnum;
412 CHECK_VAL(break_info.count, 0);
413 CHECK_VAL(break_info.fnum, 0);
414 CHECK_VAL(break_info.failures, 0);
415 CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
417 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
418 NTCREATEX_FLAGS_REQUEST_OPLOCK |
419 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
420 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
421 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
422 NTCREATEX_SHARE_ACCESS_WRITE|
423 NTCREATEX_SHARE_ACCESS_DELETE;
424 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
425 status = smb_raw_open(cli->tree, mem_ctx, &io);
426 CHECK_STATUS(status, NT_STATUS_OK);
427 fnum2 = io.ntcreatex.out.file.fnum;
428 CHECK_VAL(break_info.count, 0);
429 CHECK_VAL(break_info.fnum, 0);
430 CHECK_VAL(break_info.failures, 0);
431 CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
433 printf("write should trigger a break to none\n");
436 wr.write.level = RAW_WRITE_WRITE;
437 wr.write.in.file.fnum = fnum;
438 wr.write.in.count = 1;
439 wr.write.in.offset = 0;
440 wr.write.in.remaining = 0;
441 wr.write.in.data = (const uint8_t *)"x";
442 status = smb_raw_write(cli->tree, &wr);
443 CHECK_STATUS(status, NT_STATUS_OK);
446 /* Now the oplock break request comes in. But right now we can't
447 * answer it. Do another write */
453 wr.write.level = RAW_WRITE_WRITE;
454 wr.write.in.file.fnum = fnum;
455 wr.write.in.count = 1;
456 wr.write.in.offset = 0;
457 wr.write.in.remaining = 0;
458 wr.write.in.data = (const uint8_t *)"x";
459 status = smb_raw_write(cli->tree, &wr);
460 CHECK_STATUS(status, NT_STATUS_OK);
463 CHECK_VAL(break_info.count, 1);
464 CHECK_VAL(break_info.fnum, fnum2);
465 CHECK_VAL(break_info.level, 0);
466 CHECK_VAL(break_info.failures, 0);
469 smbcli_close(cli->tree, fnum);
470 smbcli_close(cli->tree, fnum2);
471 smbcli_unlink(cli->tree, fname);
477 basic testing of oplocks
479 BOOL torture_raw_oplock(struct torture_context *torture)
481 struct smbcli_state *cli1;
485 if (!torture_open_connection(&cli1)) {
489 mem_ctx = talloc_init("torture_raw_oplock");
491 if (!test_oplock(cli1, mem_ctx)) {
495 torture_close_connection(cli1);
496 talloc_free(mem_ctx);