2 Unix SMB/CIFS implementation.
3 basic raw test suite for multiplexing
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 3 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, see <http://www.gnu.org/licenses/>.
21 #include "system/filesys.h"
22 #include "libcli/raw/libcliraw.h"
23 #include "libcli/raw/raw_proto.h"
24 #include "libcli/libcli.h"
25 #include "torture/util.h"
26 #include "torture/raw/proto.h"
28 #define BASEDIR "\\test_mux"
31 test the delayed reply to a open that leads to a sharing violation
33 static bool test_mux_open(struct torture_context
*tctx
, struct smbcli_state
*cli
, TALLOC_CTX
*mem_ctx
)
39 struct smbcli_request
*req1
, *req2
;
43 printf("Testing multiplexed open/open/close\n");
45 printf("send first open\n");
46 io
.generic
.level
= RAW_OPEN_NTCREATEX
;
47 io
.ntcreatex
.in
.root_fid
.fnum
= 0;
48 io
.ntcreatex
.in
.flags
= 0;
49 io
.ntcreatex
.in
.access_mask
= SEC_FILE_READ_DATA
;
50 io
.ntcreatex
.in
.create_options
= 0;
51 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
52 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
;
53 io
.ntcreatex
.in
.alloc_size
= 0;
54 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_CREATE
;
55 io
.ntcreatex
.in
.impersonation
= NTCREATEX_IMPERSONATION_ANONYMOUS
;
56 io
.ntcreatex
.in
.security_flags
= 0;
57 io
.ntcreatex
.in
.fname
= BASEDIR
"\\open.dat";
58 status
= smb_raw_open(cli
->tree
, mem_ctx
, &io
);
59 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_OK
, "send first open");
60 fnum1
= io
.ntcreatex
.out
.file
.fnum
;
62 printf("send 2nd open, non-conflicting\n");
63 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OPEN
;
64 status
= smb_raw_open(cli
->tree
, mem_ctx
, &io
);
65 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_OK
, "send 2nd open, non-conflicting");
66 fnum2
= io
.ntcreatex
.out
.file
.fnum
;
68 tv
= timeval_current();
70 printf("send 3rd open, conflicting\n");
71 io
.ntcreatex
.in
.share_access
= 0;
72 status
= smb_raw_open(cli
->tree
, mem_ctx
, &io
);
73 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_SHARING_VIOLATION
, "send 3rd open, conflicting");
75 d
= timeval_elapsed(&tv
);
76 if (d
< 0.5 || d
> 1.5) {
77 printf("bad timeout for conflict - %.2f should be 1.0\n", d
);
79 printf("open delay %.2f\n", d
);
82 printf("send async open, conflicting\n");
83 tv
= timeval_current();
84 req1
= smb_raw_open_send(cli
->tree
, &io
);
86 printf("send 2nd async open, conflicting\n");
87 tv
= timeval_current();
88 req2
= smb_raw_open_send(cli
->tree
, &io
);
90 printf("close first sync open\n");
91 smbcli_close(cli
->tree
, fnum1
);
93 printf("cancel 2nd async open (should be ignored)\n");
94 smb_raw_ntcancel(req2
);
96 d
= timeval_elapsed(&tv
);
98 printf("bad timeout after cancel - %.2f should be <0.25\n", d
);
102 printf("close the 2nd sync open\n");
103 smbcli_close(cli
->tree
, fnum2
);
105 printf("see if the 1st async open now succeeded\n");
106 status
= smb_raw_open_recv(req1
, mem_ctx
, &io
);
107 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_OK
, "see if the 1st async open now succeeded");
109 d
= timeval_elapsed(&tv
);
111 printf("bad timeout for async conflict - %.2f should be <0.25\n", d
);
114 printf("async open delay %.2f\n", d
);
117 printf("2nd async open should have timed out\n");
118 status
= smb_raw_open_recv(req2
, mem_ctx
, &io
);
119 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_SHARING_VIOLATION
, "2nd async open should have timed out");
120 d
= timeval_elapsed(&tv
);
122 printf("bad timeout for async conflict - %.2f should be 1.0\n", d
);
125 printf("close the 1st async open\n");
126 smbcli_close(cli
->tree
, io
.ntcreatex
.out
.file
.fnum
);
133 test a write that hits a byte range lock and send the close after the write
135 static bool test_mux_write(struct torture_context
*tctx
, struct smbcli_state
*cli
, TALLOC_CTX
*mem_ctx
)
141 struct smbcli_request
*req
;
143 printf("Testing multiplexed lock/write/close\n");
145 fnum
= smbcli_open(cli
->tree
, BASEDIR
"\\write.dat", O_RDWR
| O_CREAT
, DENY_NONE
);
147 printf("open failed in mux_write - %s\n", smbcli_errstr(cli
->tree
));
152 cli
->session
->pid
= 1;
155 if (NT_STATUS_IS_ERR(smbcli_lock(cli
->tree
, fnum
, 0, 4, 0, WRITE_LOCK
))) {
156 printf("lock failed in mux_write - %s\n", smbcli_errstr(cli
->tree
));
161 cli
->session
->pid
= 2;
163 /* send an async write */
164 io
.generic
.level
= RAW_WRITE_WRITEX
;
165 io
.writex
.in
.file
.fnum
= fnum
;
166 io
.writex
.in
.offset
= 0;
167 io
.writex
.in
.wmode
= 0;
168 io
.writex
.in
.remaining
= 0;
169 io
.writex
.in
.count
= 4;
170 io
.writex
.in
.data
= (const uint8_t *)&fnum
;
171 req
= smb_raw_write_send(cli
->tree
, &io
);
173 /* unlock the range */
174 cli
->session
->pid
= 1;
175 smbcli_unlock(cli
->tree
, fnum
, 0, 4);
177 /* and recv the async write reply */
178 status
= smb_raw_write_recv(req
, &io
);
179 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_FILE_LOCK_CONFLICT
, "recv the async write reply");
181 smbcli_close(cli
->tree
, fnum
);
189 test a lock that conflicts with an existing lock
191 static bool test_mux_lock(struct torture_context
*tctx
, struct smbcli_state
*cli
, TALLOC_CTX
*mem_ctx
)
197 struct smbcli_request
*req
;
198 struct smb_lock_entry lock
[1];
201 printf("TESTING MULTIPLEXED LOCK/LOCK/UNLOCK\n");
203 fnum
= smbcli_open(cli
->tree
, BASEDIR
"\\write.dat", O_RDWR
| O_CREAT
, DENY_NONE
);
205 printf("open failed in mux_write - %s\n", smbcli_errstr(cli
->tree
));
210 printf("establishing a lock\n");
211 io
.lockx
.level
= RAW_LOCK_LOCKX
;
212 io
.lockx
.in
.file
.fnum
= fnum
;
213 io
.lockx
.in
.mode
= 0;
214 io
.lockx
.in
.timeout
= 0;
215 io
.lockx
.in
.lock_cnt
= 1;
216 io
.lockx
.in
.ulock_cnt
= 0;
220 io
.lockx
.in
.locks
= &lock
[0];
222 status
= smb_raw_lock(cli
->tree
, &io
);
223 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_OK
, "establishing a lock");
225 printf("the second lock will conflict with the first\n");
227 io
.lockx
.in
.timeout
= 1000;
228 status
= smb_raw_lock(cli
->tree
, &io
);
229 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_FILE_LOCK_CONFLICT
, "the second lock will conflict with the first");
231 printf("this will too, but we'll unlock while waiting\n");
232 t
= timeval_current();
233 req
= smb_raw_lock_send(cli
->tree
, &io
);
235 printf("unlock the first range\n");
237 io
.lockx
.in
.ulock_cnt
= 1;
238 io
.lockx
.in
.lock_cnt
= 0;
239 io
.lockx
.in
.timeout
= 0;
240 status
= smb_raw_lock(cli
->tree
, &io
);
241 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_OK
, "unlock the first range");
243 printf("recv the async reply\n");
244 status
= smbcli_request_simple_recv(req
);
245 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_OK
, "recv the async reply");
247 printf("async lock took %.2f msec\n", timeval_elapsed(&t
) * 1000);
248 if (timeval_elapsed(&t
) > 0.1) {
249 printf("failed to trigger early lock retry\n");
253 printf("reopening with an exit\n");
254 smb_raw_exit(cli
->session
);
255 fnum
= smbcli_open(cli
->tree
, BASEDIR
"\\write.dat", O_RDWR
| O_CREAT
, DENY_NONE
);
257 printf("Now trying with a cancel\n");
259 io
.lockx
.level
= RAW_LOCK_LOCKX
;
260 io
.lockx
.in
.file
.fnum
= fnum
;
261 io
.lockx
.in
.mode
= 0;
262 io
.lockx
.in
.timeout
= 0;
263 io
.lockx
.in
.lock_cnt
= 1;
264 io
.lockx
.in
.ulock_cnt
= 0;
268 io
.lockx
.in
.locks
= &lock
[0];
270 status
= smb_raw_lock(cli
->tree
, &io
);
271 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_OK
, "Now trying with a cancel");
274 io
.lockx
.in
.timeout
= 1000;
275 status
= smb_raw_lock(cli
->tree
, &io
);
276 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_FILE_LOCK_CONFLICT
, "Now trying with a cancel pid 2");
278 req
= smb_raw_lock_send(cli
->tree
, &io
);
280 /* cancel the blocking lock */
281 smb_raw_ntcancel(req
);
283 printf("sending 2nd cancel\n");
284 /* the 2nd cancel is totally harmless, but tests the server trying to
285 cancel an already cancelled request */
286 smb_raw_ntcancel(req
);
288 printf("sent 2nd cancel\n");
291 io
.lockx
.in
.ulock_cnt
= 1;
292 io
.lockx
.in
.lock_cnt
= 0;
293 io
.lockx
.in
.timeout
= 0;
294 status
= smb_raw_lock(cli
->tree
, &io
);
295 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_OK
, "clear lock");
297 status
= smbcli_request_simple_recv(req
);
298 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_FILE_LOCK_CONFLICT
, "recv 2nd cancel");
300 printf("cancel a lock using exit to close file\n");
302 io
.lockx
.in
.ulock_cnt
= 0;
303 io
.lockx
.in
.lock_cnt
= 1;
304 io
.lockx
.in
.timeout
= 1000;
306 status
= smb_raw_lock(cli
->tree
, &io
);
307 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_OK
, "cancel a lock using exit to close file");
309 t
= timeval_current();
311 req
= smb_raw_lock_send(cli
->tree
, &io
);
313 smb_raw_exit(cli
->session
);
314 smb_raw_exit(cli
->session
);
315 smb_raw_exit(cli
->session
);
316 smb_raw_exit(cli
->session
);
318 printf("recv the async reply\n");
319 status
= smbcli_request_simple_recv(req
);
320 torture_assert_ntstatus_equal(tctx
, status
, NT_STATUS_RANGE_NOT_LOCKED
, "recv the async reply");
321 printf("async lock exit took %.2f msec\n", timeval_elapsed(&t
) * 1000);
322 if (timeval_elapsed(&t
) > 0.1) {
323 printf("failed to trigger early lock failure\n");
334 basic testing of multiplexing notify
336 bool torture_raw_mux(struct torture_context
*torture
, struct smbcli_state
*cli
)
341 torture_assert(torture
, torture_setup_dir(cli
, BASEDIR
), "Failed to setup up test directory: " BASEDIR
);
342 frame
= talloc_stackframe();
344 ret
&= test_mux_open(torture
, cli
, frame
);
345 ret
&= test_mux_write(torture
, cli
, frame
);
346 ret
&= test_mux_lock(torture
, cli
, frame
);
348 smb_raw_exit(cli
->session
);
349 smbcli_deltree(cli
->tree
, BASEDIR
);